Squashed 'vim/bundle/syntastic/' changes from 99126e38f..106c772b0

106c772b0 More detailed logging for version operations.
2d27fd93d Formatting: use the full name for execute.
cb64516d4 Version handling: deal with errors.
1ba96436c Cleanup: handling versions.  Minor optimisation.
bcaf7cbcc Bump version number.
36ead6d75 Bump version number.
2073cee05 More safety checks.
38f46b6ac A (hopefully) safer "rm -rf".
5359f7f4e Python checker: new option g:syntastic_python_python_use_codec (@delfick).
4d1f2e23e Go checker: even more contortions.
c60e440d0 Go checker: more contortions around "go_go_build_args" and "go_go_test_args".
8b97caa2d Rubocop: "--silent" was dropped in version 0.12. (@p0deje)
5429d24a5 Phpmd: fix broken regex used for syntax highlighting.
79007b01f Manual: minor additions.
74a071331 Go checker should work with go_go_build_args unset.
be01caceb Phpcs: fix column handling.
a18ccb40d Go checker: extra arguments for "go build" and "go test".
0da7a1e47 README: minor formatting.
6bea41bdf README: rephrase.
1eb493ef3 README: add a section about recommended settings.
1d2f8d514 Formatting: folding.
c472ec139 Feature: extended syntax for `quiet_messages`.
d1b401609 Bug fix: `glob()`, `globpath()`, and `expand()` should ignore `wildignore`.
50f6b47cb README: fix reference to pathogen#infect().
d97a43bfa Sparse checker: return code 1 is less meaningful these days.
79b04bdf4 Debug: if reading a config file fails, log the reason it failed.
b340672bd Typo: remove a spurious quote.
2bb8d5996 Luacheck: highlighting patterns for version 0.7.1.
30257ef23 Luacheck: cleanup.
d2c454963 Add luacheck checker for Lua
03f43ec55 Source uglification, part III.
6de1559f3 Make SyntasticInfo aware of b:syntastic_mode.
21f052ab0 Go and govet checkers: make go executable configurable.
f583df730 Minor optimisation.
9caf33d5d If auto_jump is set to 3, jump to the first error if any.
6fdd39438 New option: b:syntastic_mode.
0c1dd2aa0 Safer closing of the error window.
c74f28ace Merge pull request #1262 from powerman/fix-perl-DATA
65de58c3a fix file/line detection for perl
d422c6d82 Flow checker: cleanup.
9dc6b6108 Updated formatting as per guidelines
55b535618 Added flow checker for javascript
9fe26f71a README: formatting.
38ba36073 README: minor cleanup.
6b9a34842 README: expand TOC.
e18c41406 README: update FAQ about validator.
30b4ce341 Validator and w3 checkers: tell curl to ignore curlrc.
67ffe5881 Merge pull request #1255 from vincent-petithory/golint-warning
7f749fe35 make golint report warnings instead of errors
650c7368e Discourage people from looking at the sources for user docs.
4354e31f9 README: rephrase.
41d571944 FAQ: add a note about HTML Tidy for HTML5.
4ff440ccb Shut up vimlint.
dbc7e39c1 Dartanalyzer can now return exit code 3.
4dba55828 Remove the avrgcc checker for Arduino.
ec2b84b12 Reek checker: cleanup.
36bb32f88 Ruby: add reek style checker
de5e025ef Scss-lint: syntax errors should have subtype syntax (@sds).
ba7d1b40b Clisp: workaround to remove ciompiled files.
72e0593ea Bug fix: make sure directory returned by syntastic#util#tmpdir() exists.
47834c034 Slightly more meaningful messages for checkers disabled by Eclim and YCM.
412d3526a Try to detect checkers disabled by YouCompleteMe.
7b6734546 Try to detect filetypes abducted by Eclim.
e4c94d67a First step towards exposing an API.
c307dde8c ghc-mod: the pylint way of handling versions is way cool, man.
82ba62ce9 Minor cleanup: wrap the main commands in their own functions.
c4c56716f More naming conventions.
64cce2083 Manual: better description of interaction with Eclim.
8e9ece214 Prospector: saner handling of errors.
83971066a Add legacy checker method setWantSort().
57f1a0eb2 New user variables: `syntastic_<filetype>_<checker>_sort`.
1327780c5 Proscpector: all tools except pylint return 1-based column numbers.
ba1b4606e Prospector: sort loclist.
dd1560862 Prospector: version 0.7 can check individual files.
3fe6f2a84 Prospector: fix typos; add logging; better return checking.
71c9a7dd0 Don't run preprocess functions if checker returned an invalid code.
72a7cb389 New checker for python: prospector.
77c125170 Bashate: cleanup.
d15590438 Merge remote-tracking branch 'aswna/add_bashate'
948202d04 Source uglification, part II.
4e9e08b50 Change case for constants' names.
f180e28a3 Closurecompiler: allow running througha shell script (@bjpbakker).
54086304b Cache balloons' contents.  Cleanup.
7ed52d1e4 README: rephrase.
e9f930be0 README: expand the section about installation.
3d5d21952 SyntasticInfo: if the current file will not be checked, explain why.
75d56b209 Manual: add a note about vim-auto-save.
47df0a035 Add license.
f4c7c5083 Add support for bashate.
008ac9829 Workaround for Vim changing the semantics of lockvar.
0bc8b2acb Don't change Vim's shell.
d665fbf56 Solve chicken-and-egg problem with getting ghc-mod version.
038f6ff8f Disable bash_hack by default.
017d89a47 Minor autoload cleanup.
aab197fb5 Formating.
dce7234fd Merge remote-tracking branch 'remko/rnc-rnv'
4a0d88ad7 Cleanup.
7829ea2b3 rnc-rnv: Change license to WTFPL
fe8054d2f Add RelaxNG (RNC) RNV checker
40776864c New checker for DocBook SGML, mdoc, and text: igor.
0e9ef6ec1 Eruby: fix logging.
19f885965 Filetype groff is actually nroff.
83d0d7fef Pylint: remove leftovers from the logging patch.
ce8939680 Checker-specific logging.
21a25649b Markdown lint: vim-markdown sets filetype to mkd.
acd02f61b Markdown lint: cleanup.
3a355fa4d Vim's filetype for Markdown is "markdown".
a188d3ae6 combine improperly separated checkers
a7e002cf4 Markdown: Added initial version of Markdown checkers
a3cf0cb65 Bro: minor errorformat fix, and highlighting.
7246fac6c Better handling of temporary directories.
049718cc6 Bug fix: SyntasticToggleMode shouldn't trigger the checks.
2a077c90c Typo.
f56742a48 Safer handling of temporary directories.
1e1c7086e README: rephrase of a FAQ question.
aa3db4513 Mypy: cleanup.
d9178ba4c Added mypy syntax plugin
0bfc328b0 The handlebars checker needs "guards".
aea964703 New checker for Linux RPM spec files: rpmlint.
ba6db9f16 New checker for Scala: scalastyle.
fe6003c3b Checkstyle checker: cleanup.
2a88120b3 More grouping in errorformat.
2f7768407 Puppet: the "future" parser outputs column numbers.
b8ca57de4 Puppet: fix errorformat.
dc4f036a6 Expand b:syntastic_<checker>_exec.
b639b007a New options.
cc3328660 FAQ: add a note about empty error windows.
6ce9bf9ab Clear loclist when running lolder at the bottom of the loclist stack.
bf2faa4d6 Manual: add a note about opening the error window.
fa0290c55 PC-Lint: mark informational messages as "Style".
9321bc79e PC-Lint: add column numbers.  Cleanup.
4f0fc20a1 Minor cleanup for text filetype.
53a321d0b README: clarifications about style checkers.
d751d17ef PC-Lint: cleanup.
3476e4f1d Merge remote-tracking branch '2sb18/pc_lint'
19ee86712 - pc_lint seems to be working well now.
fb6747c01 Grammar.
9d2800f9a README: add a note about style checkers.  Minor cleanup.
7f08cdde6 working on pc_lint checker
18a7a9ff5 Pylint checker: more versioning delirium.
5c21c4d7f Bug fix: grouping in errorformat.
131563c37 Merge pull request #1187 from rradonic/enable-warnings
e79015b0a enable warnings for eruby files
e8afec011 SASS checker: fix errorformat.
aac0775c3 Make `b:syntastic_skip_checks` suitable for general use.
7cdfd91c9 Merge pull request #1182 from russss/master
d624e32b9 Erlang: correctly handle additional LibDirs
83b6d6a58 The php checkers needs "guards" postprocessing.
4aadf589b New postprocess function: `guards`.
c2d73ffa3 Merge pull request #1177 from r3m0t/patch-1
82b2d3172 Bug fix: highlighting on python frosted checker
b7b09af6b New global option `syntastic_exit_checks`.
0d0c4aa74 Bump version.
c55384c0e Transform code using pmod_pt module before checking
f88b5c74c Bump version number.
18a185be7 PHPLint: fix syntax highlighting.
0be8cdd63 New checker for PHP: PHPLint.
80db618c0 Cursor columns: fix redraw.
d69858cc0 Merge pull request #1170 from blueyed/dont-call-expand-on-shellvar
3060c6b2e Do not `expand()` shell vars
9fb7b0d39 SCSS-Lint: new error codes.
82b274588 Don't assume loclists have vcol fields.
7b9b02954 README: typo.
4b7183b9d README: add a note about Python 3.
8e229e41a A cleaner way to kill default variables.
4cda4c3e0 Clang tools: check exit codes.
825b29a9b Clang tools: missing space.
009232652 Clang tools: work without a compilation database.  Cleanup.
8e3482b9f Merge remote-tracking branch 'bbanier/t/clang_tools' into clang_tools
e62fe0e6e Allow oclint to use cmake compilation databases.
f6e38c8b9 Merge pull request #1161 from dtwitty/patch-1
e6bf829be Fix bad variable initialization
d280dc78e Add new clang-tidy and clang-check checkers
a27b435a1 OClint: slightly more robust regexps.
1fac6011e OClint: fix parsing.
f62e0f661 New option: cursor_columns.
5c48b30c5 Fixes duplicate syntax checker for arduino files
c2e7bf29c Escript: parseShebang() is more capable these days.
e34079677 Bug fix: SyntasticReset didn't really reset.
d795d4b16 Bug fix: forgotten return.
09f35e9f2 Try to prevent g:syntastic_mode_map from being modified.
3f963543d Manual: clarification about g:syntastic_mode_map.  Minor cleanup.
95a57739e More detailed logging.
c1479f980 Set default reuse_loc_lists to 0.
d603ed4f3 Make sure version lists are formed of numbers.
e34f421b3 Revert 1e3e0a8.  The problem was placing signs on unloaded buffers.
190d9f5e9 Manual: add a note about canceling default arguments.
1d19dff70 Security: disable the elixir checker by default.
1e3e0a825 Defensive coding against stepping over other plugins' signs.
6c88bae55 JSHint checker: sort results.
5eb22bb0a Refresh optimisations: avoid floats.
b222a31d5 Typo.
0f8d786b8 Check for +float.
9a26f1d58 SyntasticInfo: minor bug fix.
13bdf9e4b SyntasticInfo: more details about modes.  Minor cleanup.
06e77c180 Manual: add a note about YouCompleteMe.
e54f28e33 New redirect checker for arduino: avrgcc.
7b0d3f868 Don't check compressed files.
d364f33a5 Refresh optimisations.
572d3e0eb README: nit pick about re-enabling the perl checker.
af4988644 Vimlint: add g:syntastic_vimlint_options.
4c5ff4272 New option for SyntasticMake(): env.
c325f6c81 Make syntastic#util#parseShebang() aware of /usr/bin/env.
dd57547da Manual: add a note about netrw.
1ee4bcccc Error highlighting cleanup.
0bef7ef3f Bug fix: refresh notifiers in BufEnter, rather than BufWinEnter.
ab79acbcc Cleanup.  Deprecate a number of checker variables.
3ebdeabf6 Add a note about rustc's new home.
bd7e34757 R lint and svtools: fix CWD for Windows.
dd5ca1f78 Add a note about the removal of the rustc checker.
1383c0f50 Remove the rustc checket for Rust.
c33303105 rustc: make arguments configurable.
17b624b86 Merge pull request #1113 from BurntSushi/makeprg-fname-param
931db14d9 filename -> fname
4004c021a ruby-lint: typo.
98b64fd7b ruby-lint: add version check for "analyze".
b61fc8af0 ruby-lint: removed analyze sub-command
3e8637ec4 New checker for sass and scss: sassc.
e058be3d0 Registry optimisation: lazy IsAvailable() calls.
284655357 Cabal checker: cleanup.
cc72b0dc6 Rename cabal/check --> cabal/cabal.
02d9f710f Add syntax checker for Haskell .cabal files
101a32bb2 coffeelint: option `--csv` is deprecated (@greenify).
b6a42d187 Vim no longer allows setting signs on line 0.
576b84e2b Update installation instructions.
50518b335 Add separate highlighting groups for style messages (@kovidgoyal).
45a36bf2f eslint: honour the exec parameter.
716038ea4 Output of pep257 has changed.
e7d1519f5 Cleanup for bro.
6ea779673 Merge remote-tracking branch 'JustinAzoff/bro'
06d8037af Merge pull request #1074 from lucc/doc
79fde89e7 Fix broken tag in docs.
653a02a4c Some versions of phcs produce an extra column: fix errorformat.
02d07313a Merge branch 'multi'
8c1c13e94 Contributing guide: add TOC; formatting.
dc02d6664 Update the contributing guide.  Make `:SyntasticInfo` print version.
43e8cb955 More clisp fixes.
24eab0313 clisp: fix argument order.
ad991127a New checker for less and css: recess (@pixelastic).
b9f741e57 Attempt at making multiple buffers work properly.
75c439fc2 Manual: add a note about PowerShell.
2a770da3a GitHub has changed the addresses for user content.
30404b914 Merge pull request #1062 from benekastah/master
9d4b17349 README: minor update.
9facbb77c fixup
748046277 Added an errorformat for eslint's warning messages
092c1f742 Merge pull request #1060 from witchard/ghdl_argument_ordering
0ae26fd22 Updated argument ordering for ghdl.
4b00bf5b2 Python checkers: workaround for GNU readline brain damage.
3c07df5df Cleanup: lock some variables.
02cbebdfa Cleanup: fix two vimlint warnings.
125442f17 tslint: cleanup.
eaa899a02 Merge remote-tracking branch 'swook/master'
54bb9b4b8 haxe and dartanalyzer: fix syntax highlighting.
b9ee43989 tslint: A basic checker configuration
618b41428 Merge remote-tracking branch 'cww/master'
ebbcdd0c1 Cleanup for java/javac.
177292caf Cleanup for the new aggregate_errors.
b1b16500a javac: Allow users to specify Maven options
99cbe5d01 HTML Tidy: add a note about HTML Tidy for HTML5.
4dbb65276 New option: syntastic_sort_aggregated_errors.
68131a767 Bug fix: error sorting.
b4320f19d oclint: option "-text" is obsolete.
4c18240e8 Formatting.
29843ed7f Minor cleanup.
f161992c1 vimlint: a more efficient IsAvailable().
4b9e87499 README: clarifications for calling multiple checkers.
41edfe34c New checker for plist XML: plutil.
81313611a Manual: minor cleanup.
9cf21436c New checker for haskell: scan.
62fde0051 Hdevtools: fix column calculations.  Cleanup.
841087fab Hlint: fix column calculations.
30198e109 Manual: add a note about vim-virtualenv.
21c7234bb Merge pull request #1046 from dan-t/master
7bd9b9834 Always give absolute paths to syntax checkers 'hdevtools' and 'hlint'
9aa1a1969 Merge pull request #1044 from riobard/fix/jsxhint
2a1e0948b R svtools: disable the checker by default, for security reasons.
e7662b946 New checker for R: svtools.
6ad57016c New checker for R: lint.
d2c0d4d83 jsxhint can be used independently.
6d05d1735 README: add anchors for FAQ items.
a62fc9eeb README: minor update.
82bff20b0 README: change address for YouCompleteMe.
8d2ac0682 Minor rephrase in the manual.
668a08bfa Add new checker for bro: bro.
0c557bfca jshint: require version 1.0.0 or later.
a781914a1 Yet more pylint versioning delirium.
f6d584bc6 splint: add errorformat sequences for Windows.
94e0e73c4 Add a note to the manual about Eclim.
4ded4f404 Expand a few config parameters.
c8f562f0f ESLint: add version check; expand config parameter.
9b1c2aa05 fix javascript/eslint format
5e275c453 Merge pull request #1027 from jseabold/patch-1
6fe4db38b Fix link.
dc6bb1121 Bump version number.
2850d4145 Minor cleanup.
da6520c69 \V<pattern> regexps can spell trouble if <pattern> contains backslashes.
223d00a0f phpcs is slow as a css checker, remove it from the defaults.
013b425c2 Make "g:syntastic_<filetype>_checkers = []" work as expected.
4fa278afe Merge pull request #1018 from lavrin/search-apps-deps-libs
2eb60cb58 Version tracking.
1fcb6b89b Don't forget about ebin/
2286363ad Properly add deps/*/include to header file path
105965c82 Simplify main/1 heads
0de089b85 Allow foreign checkers to call foreign preprocess and postprocess functions.
74121741f README: put examples in accord with the defaults.
ae65cbac4 README: minor updates, rewording, and formatting.
c18065ea5 Security: disable the perl checker by default.
e677e0655 pyflakes: update errorformat.
fb7151464 Move preprocess functions to their own file.
f490cf6ec Merge branch 'registry_refactor'
0bb8c7e5f jscs: add exit code 2 as valid (new in JSCS 1.3.0).
4196dd30d jshint: check return code.
e32343730 More preparations for the foreign checkers feature.
25271f89a Add buffer-local versions for auto_loc_list and loc_list_height.
b0191a144 Refactor of quiet_message filters.
2940b0c72 Bug fix: checker ordering.  Formatting.
47e5739f2 Formatting.
0f3a1bf45 Cleanup.
ab136c5ae Merge branch 'master' into registry_refactor
d12bc4f1d jsxhint: cleanup.
de9a02127 Add jsxhint checker
09e6840d1 Fix debug output.
c658ff15a Registry refactor.

git-subtree-dir: vim/bundle/syntastic
git-subtree-split: 106c772b055a7037f47c9ffdca01b53fa24ae6b6
main
Buddy Sandidge 10 years ago
parent 38a3cd376f
commit 0c33f9ea27

@ -1,49 +1,105 @@
# Bug reports / Github issues
# CONTRIBUTING
- - -
1\. [Bug reports / GitHub issues](#bugreps)
2\. [Submitting a patch](#patches)
3\. [General style notes](#generalstyle)
4\. [Syntax checker notes](#checkerstyle)
- - -
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.
<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][0]. 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.
* The version of syntastic you are using.
* 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
For syntax checker bugs also state the version of the checker executable that you are using.
Before you consider adding features to syntastic, _please_ spend a few
minutes (re-)reading the latest version of the [manual][1]. Syntastic
is changing rapidly at times, and it's quite possible that some of the
features you want to add exist already.
# Submitting a patch
To submit a patch:
* Fork the repo on github
* Make a [topic branch](https://github.com/dchelimsky/rspec/wiki/Topic-Branches#using-topic-branches-when-contributing-patches) and start hacking
* Submit a pull request based off your topic branch
* fork the [repo][2] on GitHub;
* make a [topic branch][3] and start hacking;
* submit a pull request based off your topic branch.
Small focused patches are preferred.
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.
Large changes to the code should be discussed with the core team first.
Create an issue and explain your plan and see what we say.
# General style notes
Also make sure to update the manual whenever applicable. Nobody can use
features that aren't documented.
Following the coding conventions/styles used in the syntastic core:
<a name="generalstyle"></a>
* Use 4 space indents.
* Don't use abbreviated keywords - e.g. use `endfunction`, not `endfun` (there's always room for more fun!).
* Don't use `l:` prefixes for variables unless actually required (i.e. almost never).
* Code for maintainability. We would rather a function be a couple of lines longer and have (for example) some [explaining variables](http://www.refactoring.com/catalog/introduceExplainingVariable.html) to aid readability.
## 3. General style notes
# Syntax checker style notes
Follow the coding conventions/styles used in the syntastic core:
The preferred style for error format strings is one "clause" per line. E.g.
(from the coffeelint checker):
* 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][4] to
aid readability.
```viml
let errorformat = '%E%f:%l:%c: %trror: %m,' .
\ 'Syntax%trror: In %f\, %m on line %l,' .
\ '%EError: In %f\, Parse error on line %l: %m,' .
\ '%EError: In %f\, %m on line %l,' .
\ '%W%f(%l): lint warning: %m,' .
\ '%W%f(%l): warning: %m,' .
\ '%E%f(%l): SyntaxError: %m,' .
\ '%-Z%p^,' .
\ '%-G%.%#'
<a name="checkerstyle"></a>
## 4. Syntax checker notes
Make sure to read the [guide][5] 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%.%#'
```
[0]: https://github.com/scrooloose/syntastic/issues
[1]: https://github.com/scrooloose/syntastic/blob/master/doc/syntastic.txt
[2]: https://github.com/scrooloose/syntastic
[3]: https://github.com/dchelimsky/rspec/wiki/Topic-Branches#using-topic-branches-when-contributing-patches
[4]: http://www.refactoring.com/catalog/extractVariable.html
[5]: https://github.com/scrooloose/syntastic/wiki/Syntax-Checker-Guide

@ -18,32 +18,51 @@
- - -
1\. [Introduction](#introduction)
2\. [Installation](#installation)
3\. [FAQ](#faq)
4\. [Other resources](#otherresources)
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. [I run a checker and the location list is not updated...](#faqloclist)
4.6. [I run`:lopen` or `:lwindow` and the error window is empty...](#faqloclist)
4.7. [How can I pass additional arguments to a checker?](#faqargs)
4.8. [Syntastic supports several checkers for my filetype - how do I tell which one(s) to use?](#faqcheckers)
4.9. [What is the difference between syntax checkers and style checkers?](#faqstyle)
4.10. [I have enabled multiple checkers for the current filetype. How can I display all of the errors from all of the checkers together?](#faqaggregate)
4.11. [How can I jump between the different errors without using the location list at the bottom of the window?](#faqlnext)
4.12. [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 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.
Syntastic is a syntax checking plugin for [Vim][13] that runs files through
external syntax checkers and displays any resulting errors to the user. This
can be done on demand, or automatically as files are saved. If syntax errors
are detected, the user is notified and is happy because they didn't have to
compile their code or execute their script to find them.
At the time of this writing, syntax checking plugins exist for ActionScript,
Ada, AppleScript, AsciiDoc, ASM, BEMHTML, Bourne shell, C, C++, C#, Chef,
CoffeeScript, Coco, Coq, CSS, Cucumber, CUDA, D, Dart, DocBook, Dust, Elixir,
Erlang, eRuby, Fortran, Gentoo metadata, GLSL, Go, Haml, Haskell, Haxe,
Handlebars, HSS, HTML, Java, JavaScript, JSON, LESS, Lex, Limbo, LISP,
LLVM intermediate language, Lua, MATLAB, NASM, Objective-C, Objective-C++,
OCaml, Perl, Perl POD, PHP, gettext Portable Object, Puppet, Python, Racket,
reStructuredText, Ruby, Rust, SASS/SCSS, Scala, Slim, Tcl, TeX, Texinfo, Twig,
TypeScript, Vala, Verilog, VHDL, VimL, xHtml, XML, XSLT, YACC, YAML, z80, Zope
page templates, zsh.
Ada, AppleScript, AsciiDoc, ASM, BEMHTML, Bro, Bourne shell, C, C++, C#, Cabal,
Chef, CoffeeScript, Coco, Coq, CSS, Cucumber, CUDA, D, Dart, DocBook, Dust,
Elixir, Erlang, eRuby, Fortran, Gentoo metadata, GLSL, Go, Haml, Haskell,
Haxe, Handlebars, HSS, HTML, Java, JavaScript, JSON, JSX, LESS, Lex, Limbo,
LISP, LLVM intermediate language, Lua, Markdown, MATLAB, NASM, Objective-C,
Objective-C++, OCaml, Perl, Perl POD, PHP, gettext Portable Object, OS X and
iOS property lists, Puppet, Python, R, Racket, Relax NG, reStructuredText, RPM
spec, Ruby, SASS/SCSS, Scala, Slim, Tcl, TeX, Texinfo, Twig, TypeScript, Vala,
Verilog, VHDL, VimL, xHtml, XML, XSLT, YACC, YAML, z80, Zope page templates,
and zsh. See the [wiki][3] for details about the corresponding supported
checkers.
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
@ -62,155 +81,292 @@ enabled.
## 2\. Installation
Installing syntastic is easy but first you need to have the pathogen plugin installed. If you already
have pathogen working then skip Step 1 and go to Step 2.
<a name="requirements"></a>
<a name="step1"></a>
### 2.1\. Requirements
### 2.1\. Step 1: Install pathogen.vim
Syntastic itself has rather relaxed requirements: it doesn't have any external
dependencies, and it needs a version of [Vim][13] 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.
First I'll show you how to install tpope's [pathogen.vim][1] so that it's
easy to install syntastic. Do this in your Terminal so that you get the
pathogen.vim file and the directories it needs:
Syntastic should work with any modern plugin managers for Vim, such as
[NeoBundle][14], [Pathogen][1], [Vim-Addon-Manager][15], [Vim-Plug][16], or
[Vundle][17]. Instructions for installing syntastic with [Pathogen][1] are
included below for completeness.
mkdir -p ~/.vim/autoload ~/.vim/bundle; \
curl -so ~/.vim/autoload/pathogen.vim \
https://raw.github.com/tpope/vim-pathogen/master/autoload/pathogen.vim
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
[wiki][3] for a list of supported checkers.
Next you *need to add this* to your ~/.vimrc:
<a name="installpathogen"></a>
execute pathogen#infect()
### 2.2\. Installing syntastic with Pathogen
<a name="step2"></a>
If you already have [Pathogen][1] working then skip [Step 1](#step1) and go to
[Step 2](#step2).
### 2.2\. Step 2: Install syntastic as a pathogen bundle
<a name="step1"></a>
You now have pathogen installed and can put syntastic into ~/.vim/bundle like this:
#### 2.2.1\. Step 1: Install pathogen.vim
First I'll show you how to install Tim Pope's [Pathogen][1] so that it's easy to
install syntastic. Do this in your terminal so that you get the `pathogen.vim`
file and the directories it needs:
```sh
mkdir -p ~/.vim/autoload ~/.vim/bundle && \
curl -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>
cd ~/.vim/bundle
git clone https://github.com/scrooloose/syntastic.git
#### 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][1] right. Go back to [Step 1](#step1) and make sure you did the
following:
:Helptags
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.
If you get an error when you do this, then you probably didn't install pathogen right. Go back to
step 1 and make sure you did the following:
<a name="settings"></a>
1. Created both the ~/.vim/autoload and ~/.vim/bundle directories.
2. Added the "call pathogen#infect()" line to your ~/.vimrc file
3. Did the git clone of syntastic inside ~/.vim/bundle
4. Have permissions to access all of these directories.
## 3\. Recommended settings
Syntastic has a large number of 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>
## 3\. FAQ
## 4\. FAQ
__Q. I installed syntastic but it isn't reporting any errors...__
<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
is installed. For example: python requires either `flake8`, `pyflakes`
or `pylint` to be installed and in `$PATH`. To see which executables are
supported, just look in `syntax_checkers/<filetype>/*.vim`. Note that aliases
do not work; the actual executable must be available in your `$PATH`. Symbolic
links are okay. You can see syntastic's idea of available checkers by running
`:SyntasticInfo`.
is installed. For example: by default, python requires either `flake8` or
`pylint` to be installed and in your `$PATH`. To see which executables are
supported, look at the [wiki][3]. Note that aliases do not work; the actual
executables must be available in your `$PATH`. Symbolic links are okay though.
You can see syntastic's idea of available checkers by running `:SyntasticInfo`.
Another reason it could fail is that either the command line options or the
error output for a syntax checker may have changed. In this case, make sure you
have the latest version of the syntax checker installed. If it still fails then
create an issue - or better yet, create a pull request.
__Q. Recently some of my syntax checker options have stopped working...__
<a name="faqpython3"></a>
A. The options are still there, they have just been renamed. Recently,
almost all syntax checkers were refactored to use the new `makeprgBuild()`
function. This made a lot of the old explicit options redundant - as they are
now implied. The new implied options usually have slightly different names to
the old options.
__4.2. Q. The `python` checker complains about syntactically valid Python 3 constructs...__
e.g. Previously there was `g:syntastic_phpcs_conf`, now you must use
`g:syntastic_php_phpcs_args`. This completely overrides the arguments of
the checker, including any defaults, so you may need to look up the default
arguments of the checker and add these in.
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'
```
See `:help syntastic-checker-options` for more information.
<a name="faqhtml5"></a>
__4.3. Q. Are there any local checkers for HTML5 that I can use with syntastic?__
__Q. I run a checker and the location list is not updated...__
[HTML Tidy][18] has a fork named [HTML Tidy for HTML5][19]. 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.
A. By default, the location list is changed only when you run the `:Errors`
Alternatively, you can install [vnu.jar][21] from the [validator.nu][20]
project and run it as a [HTTP server][23]:
```sh
$ java -Xss512k -cp /path/to/vnu.jar nu.validator.servlet.Main 8888
```
Then you can [configure][22] 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][10]). This is probably fine if you
wrote the file yourself, but it's a security problem if you're checking third
party files. Since there is currently no way to disable this behaviour while
still producing useful results, the checker is now disabled by default. To
(re-)enable it, 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 has been included in the [Rust compiler package][12]. If you have
a recent version of the Rust compiler, the checker should be picked up
automatically by syntastic.
<a name="faqloclist"></a>
__4.6. Q. I run a checker and the location list is not updated...__
__4.6. 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:
your `vimrc`:
```vim
let g:syntastic_always_populate_loc_list=1
let g:syntastic_always_populate_loc_list = 1
```
__Q. How can I pass additional arguments to a checker?__
<a name="faqargs"></a>
__4.7. 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 are:
```vim
syntastic_<filetype>_<subchecker>_args
```
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:
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"
let g:syntastic_ruby_mri_args = "--my --args --here"
```
See `:help syntastic-checker-options` for more information.
__Q. Syntastic supports several checkers for my filetype - how do I tell it
<a name="faqcheckers"></a>
__4.8. 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:
A. Stick a line like this in your `vimrc`:
```vim
let g:syntastic_<filetype>_checkers=['<checker-name>']
let g:syntastic_<filetype>_checkers = ['<checker-name>']
```
To see the list of checkers for your filetype, look in
`syntax_checkers/<filetype>/`.
To see the list of supported checkers for your filetype look at the
[wiki][3].
e.g. Python has the following checkers: `flake8`, `pyflakes`, `pylint` and a
native `python` checker.
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']
let g:syntastic_python_checkers = ['pylint']
```
Some filetypes, like PHP, have style checkers as well as syntax checkers. These
can be chained together like this:
Checkers can be chained together like this:
```vim
let g:syntastic_php_checkers=['php', 'phpcs', 'phpmd']
let g:syntastic_php_checkers = ['php', 'phpcs', 'phpmd']
```
This is telling syntastic to run the `php` checker first, and if no errors are
found, run `phpcs`, and then `phpmd`.
__Q. How can I jump between the different errors without using the location
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.9. 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.10. Q. I have enabled multiple checkers for the current filetype. How can I
display all of the errors from all of the 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.11. Q. How can I jump between the different errors without using the location
list at the bottom of the window?__
A. Vim provides several built in commands for this. See `:help :lnext` and
`:help :lprev`.
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][2], which provides such
your `vimrc`, or install something like [unimpaired][2], which provides such
mappings (among other things).
__Q. A syntax checker is giving me unwanted/strange style tips?__
A. Some filetypes (e.g. php) have style checkers as well as syntax
checkers. You can usually configure the options that are passed to the style
checkers, or just disable them. Take a look at the [wiki][3] to see what
options are available.
<a name="faqbdelete"></a>
__Q. The error window is closed automatically when I :quit the current buffer
__4.12. 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
@ -221,14 +377,15 @@ nnoremap <silent> <C-d> :lclose<CR>:bdelete<CR>
cabbrev <silent> bd lclose\|bdelete
```
<a name="otherresources"></a>
## 4\. Other resources
## 5\. Resources
The preferred place for posting suggestions, reporting bugs, and general
discussions related to syntastic is the [issue tracker at GitHub][4]. There
are also a [google group][5], and a [syntastic tag at StackOverflow][6].
discussions related to syntastic is the [issue tracker at GitHub][4].
A guide for writing syntax checkers can be found in the [wiki][11].
There are also a dedicated [google group][5], and a
[syntastic tag at StackOverflow][6].
Syntastic aims to provide a common interface to syntax checkers for as many
languages as possible. For particular languages, there are, of course, other
@ -244,4 +401,22 @@ a look at [jedi-vim][7], [python-mode][8], or [YouCompleteMe][9].
[6]: http://stackoverflow.com/questions/tagged/syntastic
[7]: https://github.com/davidhalter/jedi-vim
[8]: https://github.com/klen/python-mode
[9]: https://github.com/Valloric/YouCompleteMe
[9]: http://valloric.github.io/YouCompleteMe/
[10]: http://perldoc.perl.org/perlrun.html#*-c*
[11]: https://github.com/scrooloose/syntastic/wiki/Syntax-Checker-Guide
[12]: https://github.com/rust-lang/rust/
[13]: http://www.vim.org/
[14]: https://github.com/Shougo/neobundle.vim
[15]: https://github.com/MarcWeber/vim-addon-manager
[16]: https://github.com/junegunn/vim-plug/
[17]: https://github.com/gmarik/Vundle.vim
[18]: http://tidy.sourceforge.net/
[19]: http://w3c.github.io/tidy-html5/
[20]: http://about.validator.nu/
[21]: https://github.com/validator/validator/releases/latest
[22]: https://github.com/scrooloose/syntastic/wiki/HTML%3A---validator
[23]: http://validator.github.io/validator/#standalone
<!--
vim:tw=79:sw=4:
-->

@ -1,4 +1,4 @@
if exists("g:loaded_syntastic_c_autoload")
if exists("g:loaded_syntastic_c_autoload") || !exists("g:loaded_syntastic_plugin")
finish
endif
let g:loaded_syntastic_c_autoload = 1
@ -10,17 +10,25 @@ set cpo&vim
" convenience function to determine the 'null device' parameter
" based on the current operating system
function! syntastic#c#NullOutput()
function! syntastic#c#NullOutput() " {{{2
let known_os = has('unix') || has('mac') || syntastic#util#isRunningWindows()
return known_os ? '-o ' . syntastic#util#DevNull() : ''
endfunction
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)
" search in the current file's directory upwards
function! syntastic#c#ReadConfig(file) " {{{2
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_CHECKERS, 'ReadConfig: looking for', a:file)
" search upwards from the current file's directory
let config = findfile(a:file, '.;')
if config == '' || !filereadable(config)
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
@ -30,7 +38,8 @@ function! syntastic#c#ReadConfig(file)
" try to read config file
try
let lines = readfile(config)
catch /^Vim\%((\a\+)\)\=:E48[45]/
catch /\m^Vim\%((\a\+)\)\=:E48[45]/
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_CHECKERS, 'ReadConfig: error reading file')
return ''
endtry
@ -57,12 +66,12 @@ function! syntastic#c#ReadConfig(file)
endfor
return join(map(parameters, 'syntastic#util#shescape(v:val)'))
endfunction
endfunction " }}}2
" GetLocList() for C-like compilers
function! syntastic#c#GetLocList(filetype, subchecker, options)
function! syntastic#c#GetLocList(filetype, subchecker, options) " {{{2
try
let flags = s:GetCflags(a:filetype, a:subchecker, a:options)
let flags = s:_get_cflags(a:filetype, a:subchecker, a:options)
catch /\m\C^Syntastic: skip checks$/
return []
endtry
@ -70,9 +79,9 @@ function! syntastic#c#GetLocList(filetype, subchecker, options)
let makeprg = syntastic#util#shexpand(g:syntastic_{a:filetype}_compiler) .
\ ' ' . flags . ' ' . syntastic#util#shexpand('%')
let errorformat = s:GetCheckerVar('g', a:filetype, a:subchecker, 'errorformat', a:options['errorformat'])
let errorformat = s:_get_checker_var('g', a:filetype, a:subchecker, 'errorformat', a:options['errorformat'])
let postprocess = s:GetCheckerVar('g', a:filetype, a:subchecker, 'remove_include_errors', 0) ?
let postprocess = s:_get_checker_var('g', a:filetype, a:subchecker, 'remove_include_errors', 0) ?
\ ['filterForeignErrors'] : []
" process makeprg
@ -80,34 +89,112 @@ function! syntastic#c#GetLocList(filetype, subchecker, options)
\ 'makeprg': makeprg,
\ 'errorformat': errorformat,
\ 'postprocess': postprocess })
endfunction
endfunction " }}}2
" }}}1
" Private functions {{{1
" initialize c/cpp syntax checker handlers
function! s:Init()
function! s:_init() " {{{2
let s:handlers = []
let s:cflags = {}
call s:RegHandler('\m\<cairo', 'syntastic#c#CheckPKG', ['cairo', 'cairo'])
call s:RegHandler('\m\<freetype', 'syntastic#c#CheckPKG', ['freetype', 'freetype2', 'freetype'])
call s:RegHandler('\m\<glade', 'syntastic#c#CheckPKG', ['glade', 'libglade-2.0', 'libglade'])
call s:RegHandler('\m\<glib', 'syntastic#c#CheckPKG', ['glib', 'glib-2.0', 'glib'])
call s:RegHandler('\m\<gtk', 'syntastic#c#CheckPKG', ['gtk', 'gtk+-2.0', 'gtk+', 'glib-2.0', 'glib'])
call s:RegHandler('\m\<libsoup', 'syntastic#c#CheckPKG', ['libsoup', 'libsoup-2.4', 'libsoup-2.2'])
call s:RegHandler('\m\<libxml', 'syntastic#c#CheckPKG', ['libxml', 'libxml-2.0', 'libxml'])
call s:RegHandler('\m\<pango', 'syntastic#c#CheckPKG', ['pango', 'pango'])
call s:RegHandler('\m\<SDL', 'syntastic#c#CheckPKG', ['sdl', 'sdl'])
call s:RegHandler('\m\<opengl', 'syntastic#c#CheckPKG', ['opengl', 'gl'])
call s:RegHandler('\m\<webkit', 'syntastic#c#CheckPKG', ['webkit', 'webkit-1.0'])
call s:RegHandler('\m\<php\.h\>', 'syntastic#c#CheckPhp', [])
call s:RegHandler('\m\<Python\.h\>', 'syntastic#c#CheckPython', [])
call s:RegHandler('\m\<ruby', 'syntastic#c#CheckRuby', [])
endfunction
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) " {{{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, ...) " {{{2
if executable('pkg-config')
if !has_key(s:cflags, a:name)
for pkg in a:000
let pkg_flags = system('pkg-config --cflags ' . pkg)
" since we cannot necessarily trust the pkg-config exit code
" we have to check for an error output as well
if v:shell_error == 0 && pkg_flags !~? 'not found'
let pkg_flags = ' ' . substitute(pkg_flags, "\n", '', '')
let s:cflags[a:name] = pkg_flags
return pkg_flags
endif
endfor
else
return s:cflags[a:name]
endif
endif
return ''
endfunction " }}}2
" try to find PHP includes with 'php-config'
function! s:_checkPhp() " {{{2
if executable('php-config')
if !has_key(s:cflags, 'php')
let s:cflags['php'] = system('php-config --includes')
let s:cflags['php'] = ' ' . substitute(s:cflags['php'], "\n", '', '')
endif
return s:cflags['php']
endif
return ''
endfunction " }}}2
" try to find the python headers with distutils
function! s:_checkPython() " {{{2
if executable('python')
if !has_key(s:cflags, 'python')
let s:cflags['python'] = system('python -c ''from distutils import ' .
\ 'sysconfig; import sys; sys.stdout.write(sysconfig.get_python_inc())''')
let s:cflags['python'] = substitute(s:cflags['python'], "\n", '', '')
let s:cflags['python'] = ' -I' . s:cflags['python']
endif
return s:cflags['python']
endif
return ''
endfunction " }}}2
" try to find the ruby headers with 'rbconfig'
function! s:_checkRuby() " {{{2
if executable('ruby')
if !has_key(s:cflags, 'ruby')
let s:cflags['ruby'] = system('ruby -r rbconfig -e ' .
\ '''puts RbConfig::CONFIG["rubyhdrdir"] || RbConfig::CONFIG["archdir"]''')
let s:cflags['ruby'] = substitute(s:cflags['ruby'], "\n", '', '')
let s:cflags['ruby'] = ' -I' . s:cflags['ruby']
endif
return s:cflags['ruby']
endif
return ''
endfunction " }}}2
" }}}1
" Utilities {{{1
" resolve checker-related user variables
function! s:GetCheckerVar(scope, filetype, subchecker, name, default)
function! s:_get_checker_var(scope, filetype, subchecker, name, default) " {{{2
let prefix = a:scope . ':' . 'syntastic_'
if exists(prefix . a:filetype . '_' . a:subchecker . '_' . a:name)
return {a:scope}:syntastic_{a:filetype}_{a:subchecker}_{a:name}
@ -116,13 +203,13 @@ function! s:GetCheckerVar(scope, filetype, subchecker, name, default)
else
return a:default
endif
endfunction
endfunction " }}}2
" resolve user CFLAGS
function! s:GetCflags(ft, ck, opts)
function! s:_get_cflags(ft, ck, opts) " {{{2
" determine whether to parse header files as well
if has_key(a:opts, 'header_names') && expand('%') =~? a:opts['header_names']
if s:GetCheckerVar('g', a:ft, a:ck, 'check_header', 0)
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
@ -132,21 +219,21 @@ function! s:GetCflags(ft, ck, opts)
let flags = get(a:opts, 'main_flags', '')
endif
let flags .= ' ' . s:GetCheckerVar('g', a:ft, a:ck, 'compiler_options', '') . ' ' . s:GetIncludeDirs(a:ft)
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:GetCheckerVar('b', a:ft, a:ck, 'cflags', '')
let b_cflags = s:_get_checker_var('b', a:ft, a:ck, 'cflags', '')
if b_cflags == ''
" check whether to search for include files at all
if !s:GetCheckerVar('g', a:ft, a:ck, 'no_include_search', 0)
if !s:_get_checker_var('g', a:ft, a:ck, 'no_include_search', 0)
if a:ft ==# 'c' || a:ft ==# 'cpp'
" refresh the include file search if desired
if s:GetCheckerVar('g', a:ft, a:ck, 'auto_refresh_includes', 0)
let flags .= ' ' . s:SearchHeaders()
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:SearchHeaders()
let b:syntastic_{a:ft}_includes = s:_search_headers()
endif
let flags .= ' ' . b:syntastic_{a:ft}_includes
endif
@ -158,18 +245,18 @@ function! s:GetCflags(ft, ck, opts)
endif
" add optional config file parameters
let config_file = s:GetCheckerVar('g', a:ft, a:ck, 'config_file', '.syntastic_' . a:ft . '_config')
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)
return flags
endfunction
endfunction " }}}2
" get the gcc include directory argument depending on the default
" includes and the optional user-defined 'g:syntastic_c_include_dirs'
function! s:GetIncludeDirs(filetype)
function! s:_get_include_dirs(filetype) " {{{2
let include_dirs = []
if a:filetype =~# '\v^%(c|cpp|d|objc|objcpp)$' &&
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)
@ -180,11 +267,11 @@ function! s:GetIncludeDirs(filetype)
endif
return join(map(syntastic#util#unique(include_dirs), 'syntastic#util#shescape("-I" . v:val)'))
endfunction
endfunction " }}}2
" search the first 100 lines for include statements that are
" given in the handlers dictionary
function! s:SearchHeaders()
function! s:_search_headers() " {{{2
let includes = ''
let files = []
let found = []
@ -210,11 +297,11 @@ function! s:SearchHeaders()
" search included headers
for hfile in files
if hfile != ''
let filename = expand('%:p:h') . syntastic#util#Slash() . hfile
let filename = expand('%:p:h', 1) . syntastic#util#Slash() . hfile
try
let lines = readfile(filename, '', 100)
catch /^Vim\%((\a\+)\)\=:E484/
catch /\m^Vim\%((\a\+)\)\=:E484/
continue
endtry
@ -237,79 +324,7 @@ function! s:SearchHeaders()
endfor
return includes
endfunction
" try to find library with 'pkg-config'
" search possible libraries from first to last given
" argument until one is found
function! syntastic#c#CheckPKG(name, ...)
if executable('pkg-config')
if !has_key(s:cflags, a:name)
for pkg in a:000
let pkg_flags = system('pkg-config --cflags ' . pkg)
" since we cannot necessarily trust the pkg-config exit code
" we have to check for an error output as well
if v:shell_error == 0 && pkg_flags !~? 'not found'
let pkg_flags = ' ' . substitute(pkg_flags, "\n", '', '')
let s:cflags[a:name] = pkg_flags
return pkg_flags
endif
endfor
else
return s:cflags[a:name]
endif
endif
return ''
endfunction
" try to find PHP includes with 'php-config'
function! syntastic#c#CheckPhp()
if executable('php-config')
if !has_key(s:cflags, 'php')
let s:cflags['php'] = system('php-config --includes')
let s:cflags['php'] = ' ' . substitute(s:cflags['php'], "\n", '', '')
endif
return s:cflags['php']
endif
return ''
endfunction
" try to find the ruby headers with 'rbconfig'
function! syntastic#c#CheckRuby()
if executable('ruby')
if !has_key(s:cflags, 'ruby')
let s:cflags['ruby'] = system('ruby -r rbconfig -e ' .
\ '''puts RbConfig::CONFIG["rubyhdrdir"] || RbConfig::CONFIG["archdir"]''')
let s:cflags['ruby'] = substitute(s:cflags['ruby'], "\n", '', '')
let s:cflags['ruby'] = ' -I' . s:cflags['ruby']
endif
return s:cflags['ruby']
endif
return ''
endfunction
" try to find the python headers with distutils
function! syntastic#c#CheckPython()
if executable('python')
if !has_key(s:cflags, 'python')
let s:cflags['python'] = system('python -c ''from distutils import ' .
\ 'sysconfig; import sys; sys.stdout.write(sysconfig.get_python_inc())''')
let s:cflags['python'] = substitute(s:cflags['python'], "\n", '', '')
let s:cflags['python'] = ' -I' . s:cflags['python']
endif
return s:cflags['python']
endif
return ''
endfunction
" return a handler dictionary object
function! s:RegHandler(regex, function, args)
let handler = {}
let handler["regex"] = a:regex
let handler["func"] = function(a:function)
let handler["args"] = a:args
call add(s:handlers, handler)
endfunction
endfunction " }}}2
" }}}1
@ -322,9 +337,9 @@ let s:default_includes = [
\ '..' . syntastic#util#Slash() . 'include',
\ '..' . syntastic#util#Slash() . 'includes' ]
call s:Init()
call s:_init()
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4 fdm=marker:
" vim: set sw=4 sts=4 et fdm=marker:

@ -1,4 +1,4 @@
if exists("g:loaded_syntastic_log_autoload")
if exists("g:loaded_syntastic_log_autoload") || !exists("g:loaded_syntastic_plugin")
finish
endif
let g:loaded_syntastic_log_autoload = 1
@ -6,73 +6,67 @@ let g:loaded_syntastic_log_autoload = 1
let s:save_cpo = &cpo
set cpo&vim
if !exists("g:syntastic_debug")
let g:syntastic_debug = 0
endif
let s:global_options = [
\ 'syntastic_aggregate_errors',
\ 'syntastic_always_populate_loc_list',
\ 'syntastic_auto_jump',
\ 'syntastic_auto_loc_list',
\ 'syntastic_check_on_open',
\ 'syntastic_check_on_wq',
\ 'syntastic_debug',
\ 'syntastic_echo_current_error',
\ 'syntastic_enable_balloons',
\ 'syntastic_enable_highlighting',
\ 'syntastic_enable_signs',
\ 'syntastic_error_symbol',
\ 'syntastic_filetype_map',
\ 'syntastic_full_redraws',
\ 'syntastic_id_checkers',
\ 'syntastic_ignore_files',
\ 'syntastic_loc_list_height',
\ 'syntastic_mode_map',
\ 'syntastic_quiet_messages',
\ 'syntastic_reuse_loc_lists',
\ 'syntastic_stl_format',
\ 'syntastic_style_error_symbol',
\ 'syntastic_style_warning_symbol',
\ 'syntastic_warning_symbol' ]
let s:deprecation_notices_issued = []
let s:one_time_notices_issued = []
" Public functions {{{1
function! syntastic#log#info(msg)
function! syntastic#log#info(msg) " {{{2
echomsg "syntastic: info: " . a:msg
endfunction
endfunction " }}}2
function! syntastic#log#warn(msg)
function! syntastic#log#warn(msg) " {{{2
echohl WarningMsg
echomsg "syntastic: warning: " . a:msg
echohl None
endfunction
endfunction " }}}2
function! syntastic#log#error(msg)
function! syntastic#log#error(msg) " {{{2
execute "normal \<Esc>"
echohl ErrorMsg
echomsg "syntastic: error: " . a:msg
echohl None
endfunction
endfunction " }}}2
function! syntastic#log#deprecationWarn(msg)
if index(s:deprecation_notices_issued, a:msg) >= 0
function! syntastic#log#oneTimeWarn(msg) " {{{2
if index(s:one_time_notices_issued, a:msg) >= 0
return
endif
call add(s:deprecation_notices_issued, a:msg)
call add(s:one_time_notices_issued, a:msg)
call syntastic#log#warn(a:msg)
endfunction
endfunction " }}}2
" @vimlint(EVL102, 1, l:OLD_VAR)
function! syntastic#log#deprecationWarn(old, new, ...) " {{{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
function! syntastic#log#debug(level, msg, ...)
if !s:isDebugEnabled(a:level)
call syntastic#log#oneTimeWarn(msg)
endif
endfunction " }}}2
" @vimlint(EVL102, 0, l:OLD_VAR)
function! syntastic#log#debug(level, msg, ...) " {{{2
if !s:_isDebugEnabled(a:level)
return
endif
let leader = s:logTimestamp()
call s:logRedirect(1)
let leader = s:_log_timestamp()
call s:_logRedirect(1)
if a:0 > 0
" filter out dictionary functions
@ -83,68 +77,74 @@ function! syntastic#log#debug(level, msg, ...)
echomsg leader . a:msg
endif
call s:logRedirect(0)
endfunction
call s:_logRedirect(0)
endfunction " }}}2
function! syntastic#log#debugShowOptions(level, names)
if !s:isDebugEnabled(a:level)
function! syntastic#log#debugShowOptions(level, names) " {{{2
if !s:_isDebugEnabled(a:level)
return
endif
let leader = s:logTimestamp()
call s:logRedirect(1)
let leader = s:_log_timestamp()
call s:_logRedirect(1)
let vlist = type(a:names) == type("") ? [a:names] : a:names
let vlist = copy(type(a:names) == type("") ? [a:names] : a:names)
if !empty(vlist)
call map(copy(vlist), "'&' . v:val . ' = ' . strtrans(string(eval('&' . v:val)))")
call map(vlist, "'&' . v:val . ' = ' . strtrans(string(eval('&' . v:val)))")
echomsg leader . join(vlist, ', ')
endif
call s:logRedirect(0)
endfunction
call s:_logRedirect(0)
endfunction " }}}2
function! syntastic#log#debugShowVariables(level, names)
if !s:isDebugEnabled(a:level)
function! syntastic#log#debugShowVariables(level, names) " {{{2
if !s:_isDebugEnabled(a:level)
return
endif
let leader = s:logTimestamp()
call s:logRedirect(1)
let leader = s:_log_timestamp()
call s:_logRedirect(1)
let vlist = type(a:names) == type("") ? [a:names] : a:names
for name in vlist
echomsg leader . s:formatVariable(name)
let msg = s:_format_variable(name)
if msg != ''
echomsg leader . msg
endif
endfor
call s:logRedirect(0)
endfunction
call s:_logRedirect(0)
endfunction " }}}2
function! syntastic#log#debugDump(level)
if !s:isDebugEnabled(a:level)
function! syntastic#log#debugDump(level) " {{{2
if !s:_isDebugEnabled(a:level)
return
endif
call syntastic#log#debugShowVariables(a:level, s:global_options)
endfunction
call syntastic#log#debugShowVariables( a:level, sort(keys(g:_SYNTASTIC_DEFAULTS)) )
endfunction " }}}2
" }}}1
" Private functions {{{1
function! s:isDebugEnabled_smart(level)
function! s:_isDebugEnabled_smart(level) " {{{2
return and(g:syntastic_debug, a:level)
endfunction
endfunction " }}}2
function! s:isDebugEnabled_dumb(level)
function! s:_isDebugEnabled_dumb(level) " {{{2
" poor man's bit test for bit N, assuming a:level == 2**N
return (g:syntastic_debug / a:level) % 2
endfunction
endfunction " }}}2
let s:isDebugEnabled = function(exists('*and') ? 's:isDebugEnabled_smart' : 's:isDebugEnabled_dumb')
let s:_isDebugEnabled = function(exists('*and') ? 's:_isDebugEnabled_smart' : 's:_isDebugEnabled_dumb')
lockvar s:_isDebugEnabled
function! s:logRedirect(on)
function! s:_logRedirect(on) " {{{2
if exists("g:syntastic_debug_file")
if a:on
try
execute 'redir >> ' . fnameescape(expand(g:syntastic_debug_file))
catch /^Vim\%((\a\+)\)\=:/
execute 'redir >> ' . fnameescape(expand(g:syntastic_debug_file, 1))
catch /\m^Vim\%((\a\+)\)\=:/
silent! redir END
unlet g:syntastic_debug_file
endtry
@ -152,30 +152,31 @@ function! s:logRedirect(on)
silent! redir END
endif
endif
endfunction
endfunction " }}}2
function! s:logTimestamp_smart()
return 'syntastic: ' . split(reltimestr(reltime(g:syntastic_start)))[0] . ': '
endfunction
" }}}1
function! s:logTimestamp_dumb()
return 'syntastic: debug: '
endfunction
" Utilities {{{1
let s:logTimestamp = function(has('reltime') ? 's:logTimestamp_smart' : 's:logTimestamp_dumb')
function! s:_log_timestamp() " {{{2
return 'syntastic: ' . split(reltimestr(reltime(g:_SYNTASTIC_START)))[0] . ': '
endfunction " }}}2
function! s:formatVariable(name)
function! s:_format_variable(name) " {{{2
let vals = []
if exists('g:' . a:name)
call add(vals, 'g:' . a:name . ' = ' . strtrans(string(g:{a:name})))
if exists('g:syntastic_' . a:name)
call add(vals, 'g:syntastic_' . a:name . ' = ' . strtrans(string(g:syntastic_{a:name})))
endif
if exists('b:' . a:name)
call add(vals, 'b:' . a:name . ' = ' . strtrans(string(b:{a:name})))
if exists('b:syntastic_' . a:name)
call add(vals, 'b:syntastic_' . a:name . ' = ' . strtrans(string(b:syntastic_{a:name})))
endif
return join(vals, ', ')
endfunction
endfunction " }}}2
" }}}1
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4 fdm=marker:
" vim: set sw=4 sts=4 et fdm=marker:

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

@ -0,0 +1,262 @@
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) " {{{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) " {{{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) " {{{2
return map(copy(a:errors), 'substitute(v:val, ''\v^\[[^]]+\]\zs( -\> \[[^]]+\])+\ze:'', "", "")')
endfunction " }}}2
" @vimlint(EVL102, 1, l:true)
" @vimlint(EVL102, 1, l:false)
" @vimlint(EVL102, 1, l:null)
function! syntastic#preprocess#flow(errors) " {{{2
" JSON artifacts
let true = 1
let false = 0
let null = ''
" A hat tip to Marc Weber for this trick
" http://stackoverflow.com/questions/17751186/iterating-over-a-string-in-vimscript-or-parse-a-json-file/19105763#19105763
try
let errs = eval(join(a:errors, ''))
catch
let errs = {}
endtry
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'] ? 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: unknown error format')
let out = []
break
endtry
else
call syntastic#log#warn('checker javascript/flow: unknown error format')
let out = []
break
endif
endfor
else
call syntastic#log#warn('checker javascript/flow: unknown error format')
endif
return out
endfunction " }}}2
" @vimlint(EVL102, 0, l:true)
" @vimlint(EVL102, 0, l:false)
" @vimlint(EVL102, 0, l:null)
function! syntastic#preprocess#killEmpty(errors) " {{{2
return filter(copy(a:errors), 'v:val != ""')
endfunction " }}}2
function! syntastic#preprocess#perl(errors) " {{{2
let out = []
for e in a:errors
let parts = matchlist(e, '\v^(.*)\sat\s(.{-})\sline\s(\d+)(.*)$')
if !empty(parts)
call add(out, parts[2] . ':' . parts[3] . ':' . parts[1] . parts[4])
endif
endfor
return syntastic#util#unique(out)
endfunction " }}}2
" @vimlint(EVL102, 1, l:true)
" @vimlint(EVL102, 1, l:false)
" @vimlint(EVL102, 1, l:null)
function! syntastic#preprocess#prospector(errors) " {{{2
" JSON artifacts
let true = 1
let false = 0
let null = ''
" A hat tip to Marc Weber for this trick
" http://stackoverflow.com/questions/17751186/iterating-over-a-string-in-vimscript-or-parse-a-json-file/19105763#19105763
try
let errs = eval(join(a:errors, ''))
catch
let errs = {}
endtry
let out = []
if type(errs) == type({}) && has_key(errs, 'messages') && 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: unknown error format')
let out = []
break
endtry
else
call syntastic#log#warn('checker python/prospector: unknown error format')
let out = []
break
endif
endfor
else
call syntastic#log#warn('checker python/prospector: unknown error format')
endif
return out
endfunction " }}}2
" @vimlint(EVL102, 0, l:true)
" @vimlint(EVL102, 0, l:false)
" @vimlint(EVL102, 0, l:null)
function! syntastic#preprocess#rparse(errors) " {{{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#tslint(errors) " {{{2
return map(copy(a:errors), 'substitute(v:val, ''\m^\(([^)]\+)\)\s\(.\+\)$'', ''\2 \1'', "")')
endfunction " }}}2
function! syntastic#preprocess#validator(errors) " {{{2
let out = []
for e in a:errors
let parts = matchlist(e, '\v^"([^"]+)"(.+)')
if len(parts) >= 3
" URL decode, except leave alone any "+"
let parts[1] = substitute(parts[1], '\m%\(\x\x\)', '\=nr2char("0x".submatch(1))', 'g')
let parts[1] = substitute(parts[1], '\m\\"', '"', 'g')
let parts[1] = substitute(parts[1], '\m\\\\', '\\', 'g')
call add(out, '"' . parts[1] . '"' . parts[2])
endif
endfor
return out
endfunction " }}}2
" }}}1
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set sw=4 sts=4 et fdm=marker:

@ -1,4 +1,4 @@
if exists('g:loaded_syntastic_util_autoload')
if exists('g:loaded_syntastic_util_autoload') || !exists("g:loaded_syntastic_plugin")
finish
endif
let g:loaded_syntastic_util_autoload = 1
@ -6,27 +6,83 @@ let g:loaded_syntastic_util_autoload = 1
let s:save_cpo = &cpo
set cpo&vim
" 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')
" Public functions {{{1
function! syntastic#util#isRunningWindows()
function! syntastic#util#isRunningWindows() " {{{2
return has('win16') || has('win32') || has('win64')
endfunction
endfunction " }}}2
function! syntastic#util#DevNull()
function! syntastic#util#DevNull() " {{{2
if syntastic#util#isRunningWindows()
return 'NUL'
endif
return '/dev/null'
endfunction
endfunction " }}}2
" Get directory separator
function! syntastic#util#Slash() abort
function! syntastic#util#Slash() abort " {{{2
return (!exists("+shellslash") || &shellslash) ? '/' : '\'
endfunction
endfunction " }}}2
" Create a temporary directory
function! syntastic#util#tmpdir() " {{{2
let tempdir = ''
if (has('unix') || has('mac')) && executable('mktemp')
" TODO: option "-t" to mktemp(1) is not portable
let tmp = $TMPDIR != '' ? $TMPDIR : $TMP != '' ? $TMP : '/tmp'
let out = split(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 = s: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) " {{{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'
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 system(s:rmrf . ' ' . syntastic#util#shescape(a:what))
else
call s:_rmrf(a:what)
endif
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
@ -38,37 +94,32 @@ endfunction
"returns
"
"{'exe': '/usr/bin/perl', 'args': ['-f', '-bar']}
function! syntastic#util#parseShebang()
for lnum in range(1,5)
function! syntastic#util#parseShebang() " {{{2
for lnum in range(1, 5)
let line = getline(lnum)
if line =~ '^#!'
let exe = matchstr(line, '\m^#!\s*\zs[^ \t]*')
let args = split(matchstr(line, '\m^#!\s*[^ \t]*\zs.*'))
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
endfunction " }}}2
" Get the value of a variable. Allow local variables to override global ones.
function! syntastic#util#var(name)
function! syntastic#util#var(name, ...) " {{{2
return
\ exists('b:syntastic_' . a:name) ? b:syntastic_{a:name} :
\ exists('g:syntastic_' . a:name) ? g:syntastic_{a:name} : ''
endfunction
\ exists('g:syntastic_' . a:name) ? g:syntastic_{a:name} :
\ a:0 > 0 ? a:1 : ''
endfunction " }}}2
" Parse a version string. Return an array of version components.
function! syntastic#util#parseVersion(version)
return split(matchstr( a:version, '\v^\D*\zs\d+(\.\d+)+\ze' ), '\m\.')
endfunction
" Run 'command' in a shell and parse output as a version string.
" Returns an array of version components.
function! syntastic#util#getVersion(command)
return syntastic#util#parseVersion(system(a:command))
endfunction
function! syntastic#util#parseVersion(version) " {{{2
return map(split(matchstr( a:version, '\v^\D*\zs\d+(\.\d+)+\ze' ), '\m\.'), 'str2nr(v:val)')
endfunction " }}}2
" Verify that the 'installed' version is at least the 'required' version.
"
@ -76,20 +127,41 @@ endfunction
" the "missing" elements will be assumed to be 0 for the purposes of checking.
"
" See http://semver.org for info about version numbers.
function! syntastic#util#versionIsAtLeast(installed, required)
for idx in range(max([len(a:installed), len(a:required)]))
let installed_element = get(a:installed, idx, 0)
let required_element = get(a:required, idx, 0)
if installed_element != required_element
return installed_element > required_element
function! syntastic#util#versionIsAtLeast(installed, required) " {{{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) " {{{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
" Everything matched, so it is at least the required version.
return 1
endfunction
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) " {{{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)
function! syntastic#util#wideMsg(msg) " {{{2
let old_ruler = &ruler
let old_showcmd = &showcmd
@ -100,7 +172,7 @@ function! syntastic#util#wideMsg(msg)
"convert tabs to spaces so that the tabs count towards the window
"width as the proper amount of characters
let chunks = split(msg, "\t", 1)
let msg = join(map(chunks[:-2], 'v:val . repeat(" ", &ts - s:width(v:val) % &ts)'), '') . chunks[-1]
let msg = 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
@ -110,10 +182,10 @@ function! syntastic#util#wideMsg(msg)
let &ruler = old_ruler
let &showcmd = old_showcmd
endfunction
endfunction " }}}2
" Check whether a buffer is loaded, listed, and not hidden
function! syntastic#util#bufIsActive(buffer)
function! syntastic#util#bufIsActive(buffer) " {{{2
" convert to number, or hell breaks loose
let buf = str2nr(a:buffer)
@ -129,11 +201,11 @@ function! syntastic#util#bufIsActive(buffer)
endfor
return 0
endfunction
endfunction " }}}2
" start in directory a:where and walk up the parent folders until it
" finds a file matching a:what; return path to that file
function! syntastic#util#findInParent(what, where)
function! syntastic#util#findInParent(what, where) " {{{2
let here = fnamemodify(a:where, ':p')
let root = syntastic#util#Slash()
@ -146,7 +218,7 @@ function! syntastic#util#findInParent(what, where)
let old = ''
while here != ''
let p = split(globpath(here, a:what), '\n')
let p = split(globpath(here, a:what, 1), '\n')
if !empty(p)
return fnamemodify(p[0], ':p')
@ -162,10 +234,10 @@ function! syntastic#util#findInParent(what, where)
endwhile
return ''
endfunction
endfunction " }}}2
" Returns unique elements in a list
function! syntastic#util#unique(list)
function! syntastic#util#unique(list) " {{{2
let seen = {}
let uniques = []
for e in a:list
@ -175,20 +247,31 @@ function! syntastic#util#unique(list)
endif
endfor
return uniques
endfunction
endfunction " }}}2
" A less noisy shellescape()
function! syntastic#util#shescape(string)
function! syntastic#util#shescape(string) " {{{2
return a:string =~ '\m^[A-Za-z0-9_/.-]\+$' ? a:string : shellescape(a:string)
endfunction
endfunction " }}}2
" A less noisy shellescape(expand())
function! syntastic#util#shexpand(string)
return syntastic#util#shescape(expand(a:string))
endfunction
function! syntastic#util#shexpand(string, ...) " {{{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) " {{{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)
function! syntastic#util#decodeXMLEntities(string) " {{{2
let str = a:string
let str = substitute(str, '\m&lt;', '<', 'g')
let str = substitute(str, '\m&gt;', '>', 'g')
@ -196,56 +279,114 @@ function! syntastic#util#decodeXMLEntities(string)
let str = substitute(str, '\m&apos;', "'", 'g')
let str = substitute(str, '\m&amp;', '\&', 'g')
return str
endfunction
endfunction " }}}2
function! syntastic#util#redraw(full)
function! syntastic#util#redraw(full) " {{{2
if a:full
redraw!
else
redraw
endif
endfunction
endfunction " }}}2
function! syntastic#util#dictFilter(errors, filter)
let rules = s:translateFilter(a:filter)
" call syntastic#log#debug(g:SyntasticDebugFilters, "applying filter:", rules)
function! syntastic#util#dictFilter(errors, filter) " {{{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
endfunction " }}}2
" Return a [high, low] list of integers, representing the time
" (hopefully high resolution) since program start
" TODO: This assumes reltime() returns a list of integers.
function! syntastic#util#stamp() " {{{2
return reltime(g:_SYNTASTIC_START)
endfunction " }}}2
" }}}1
" Private functions {{{1
function! s:translateFilter(filters)
function! s:_translateFilter(filters) " {{{2
let conditions = []
for k in keys(a:filters)
if type(a:filters[k]) == type([])
call extend(conditions, map(copy(a:filters[k]), 's:translateElement(k, v:val)'))
call extend(conditions, map(copy(a:filters[k]), 's:_translateElement(k, v:val)'))
else
call add(conditions, s:translateElement(k, a:filters[k]))
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
function! s:translateElement(key, term)
if a:key ==? 'level'
let ret = 'v:val["type"] !=? ' . string(a:term[0])
elseif a:key ==? 'type'
let ret = a:term ==? 'style' ? 'get(v:val, "subtype", "") !=? "style"' : 'has_key(v:val, "subtype")'
elseif a:key ==? 'regex'
let ret = 'v:val["text"] !~? ' . string(a:term)
elseif a:key ==? 'file'
let ret = 'bufname(str2nr(v:val["bufnr"])) !~# ' . string(a:term)
endfunction " }}}2
function! s:_translateElement(key, term) " {{{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
endfunction " }}}2
function! s:_rmrf(what) " {{{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
for f in split(globpath(a:what, '*', 1), "\n")
call s:_rmrf(f)
endfor
silent! call system(s:rmdir . ' ' . syntastic#util#shescape(a:what))
else
silent! call delete(a:what)
endif
endfunction " }}}2
" }}}1
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4 fdm=marker:
" vim: set sw=4 sts=4 et fdm=marker:

@ -21,6 +21,7 @@ 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|
@ -34,11 +35,18 @@ CONTENTS *syntastic-contents*
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|
6.Notes........................................|syntastic-notes|
6.1.Handling of composite filetypes........|syntastic-composite|
6.2.Interaction with python-mode...........|syntastic-pymode|
6.3.Interaction with the fish shell........|syntastic-fish|
6.4.Using syntastic with the fizsh shell...|syntastic-fizsh|
6.2.Editing files over network.............|syntastic-netrw|
6.3.Interaction with python-mode...........|syntastic-pymode|
6.4.Interaction with YouCompleteMe.........|syntastic-ycm|
6.5.Interaction with the fish shell........|syntastic-fish|
6.6.Interaction with PowerShell............|syntastic-powershell|
6.7.Using syntastic with the fizsh shell...|syntastic-fizsh|
6.8.Interaction with Eclim.................|syntastic-eclim|
6.9.Interaction with vim-virtualenv........|syntastic-vim-virtualenv|
6.10.Interaction with vim-auto-save........|syntastic-vim-auto-save|
7.About........................................|syntastic-about|
8.License......................................|syntastic-license|
@ -62,7 +70,7 @@ Take a look at the wiki for a list of supported filetypes and checkers:
https://github.com/scrooloose/syntastic/wiki/Syntax-Checkers
Note: This doc only deals with using syntastic. To learn how to write syntax
checker integrations, see the guide on the github wiki:
checker integrations, see the guide on the GitHub wiki:
https://github.com/scrooloose/syntastic/wiki/Syntax-Checker-Guide
@ -73,17 +81,40 @@ Syntastic comes preconfigured with a default list of enabled checkers per
filetype. This list is kept reasonably short to prevent slowing down Vim or
trying to use conflicting checkers.
You can see the list checkers available for the current filetype with the
You can see the list of checkers available for the current filetype with the
|:SyntasticInfo| command.
If you want to override the configured list of checkers for a filetype then
see |syntastic-checker-options| for details. You can also change the arguments
passed to a specific checker as well.
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 |:SyntasticToggleMode|
to switch between active (checking on writting the buffer) and passive (manual)
checking.
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 a large number of 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*
@ -91,7 +122,7 @@ Syntax checking can be done automatically or on demand (see
|'syntastic_mode_map'| and |:SyntasticToggleMode| for configuring this).
When syntax checking is done, the features below can be used to notify the
user of errors. See |syntastic-options| for how to configure and
user of errors. See |syntastic-global-options| for how to configure and
activate/deactivate these features.
* A statusline flag
@ -150,13 +181,22 @@ Example: >
highlight SyntasticErrorLine guibg=#2f0000
<
------------------------------------------------------------------------------
2.3. The error window *:Errors* *syntastic-error-window*
2.3. The error window *syntastic-error-window*
You can use the :Errors command to display the errors for the current buffer
You can use the |:Errors| command to display the errors for the current buffer
in the |location-list|.
Note that when you use :Errors, the current location list is overwritten with
Syntastic's own location list.
Note that when you use |:Errors| the current location list is overwritten with
Syntastic's own location list. The location list is also overwritten when
|syntastic_auto_jump| is non-zero and the cursor has to jump to an issue.
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*
@ -167,6 +207,8 @@ and the SpellCap group is used for warnings. If you wish to customize the
colors for highlighting you can use the following groups:
SyntasticError - Links to 'SpellBad' by default
SyntasticWarning - Links to 'SpellCap' by default
SyntasticStyleError - Links to SyntasticError by default
SyntasticStyleWarning - Links to SyntasticWarning by default
Example: >
highlight SyntasticError guibg=#2f0000
@ -186,7 +228,13 @@ If |'syntastic_aggregate_errors'| is set, syntastic runs all checkers that
apply (still cf. |syntastic-filetype-checkers|), then aggregates errors found
by all checkers in a single list, and notifies you. In this mode each error
message is labeled with the name of the checker that generated it, but you can
disable these labels by unsetting '|syntastic_id_checkers|'.
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*
@ -200,11 +248,14 @@ See also: |'syntastic_<filetype>_<checker>_quiet_messages'|.
==============================================================================
3. Commands *syntastic-commands*
:Errors *:SyntasticErrors*
: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'|
@ -227,7 +278,7 @@ the order specified. The rules of |syntastic_aggregate_errors| still apply.
Example: >
:SyntasticCheck flake8 pylint
<
:SyntasticInfo *:SyntasticInfo*
: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
@ -278,12 +329,35 @@ a file with a composite filetype), it might not be immediately obvious which
checker has produced a given error message. This variable instructs syntastic
to label error messages with the names of the checkers that created them. >
let g:syntastic_id_checkers = 0
<
*'syntastic_sort_aggregated_errors'*
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), 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'*
Default: 1
If enabled, syntastic will echo the error associated with the current line to
the command window. If multiple errors are found, the first will be used. >
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'*
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 show. 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'*
Default: 1
@ -301,8 +375,8 @@ error symbols can be customized:
syntastic_style_warning_symbol - For style warnings, defaults to 'S>'
Example: >
let g:syntastic_error_symbol = '✗'
let g:syntastic_warning_symbol = '⚠'
let g:syntastic_error_symbol = "✗"
let g:syntastic_warning_symbol = "⚠"
<
*'syntastic_enable_balloons'*
Default: 1
@ -332,12 +406,17 @@ 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. >
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
<
*'syntastic_auto_loc_list'*
Default: 2
@ -374,71 +453,106 @@ Default: {}
Use this option to map non-standard filetypes to standard ones. Corresponding
checkers are mapped accordingly, which allows syntastic to check files with
non-standard filetypes: >
let g:syntastic_filetype_map = { 'latex': 'tex',
\ 'gentoo-metadata': 'xml' }
let g:syntastic_filetype_map = {
\ "latex": "tex",
\ "gentoo-metadata": "xml" }
<
Composite filetypes can also be mapped to simple types, which disables the
default behaviour of running both checkers against the input file: >
let g:syntastic_filetype_map = { 'handlebars.html': 'handlebars' }
let g:syntastic_filetype_map = { "handlebars.html": "handlebars" }
<
*'syntastic_mode_map'*
Default: { "mode": "active",
"active_filetypes": [],
"passive_filetypes": [] }
Use this option to fine tune when automatic syntax checking is done (or not
done).
The option should be set to something like: >
let g:syntastic_mode_map = { 'mode': 'active',
\ 'active_filetypes': ['ruby', 'php'],
\ 'passive_filetypes': ['puppet'] }
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
"mode" can be mapped to one of two values - "active" or "passive". When set
to "active", syntastic does automatic checking whenever a buffer is saved or
initially opened. When set to "passive" syntastic only checks when the user
calls |:SyntasticCheck|.
The exceptions to these rules are defined with "active_filetypes" and
"passive_filetypes". In passive mode, automatic checks are still done
for all filetypes in the "active_filetypes" array. In active mode,
automatic checks are not done for any filetypes in the
"passive_filetypes" array.
"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 mode.
active and passive modes.
If any of "mode", "active_filetypes", or "passive_filetypes" are not specified
then they will default to their default value as above.
*'b:syntastic_mode'*
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'*
Default: {}
Use this option to filter out some of the messages produced by checkers. The
option should be set to something like: >
let g:syntastic_quiet_messages = { "level": "warnings",
\ "type": "style",
\ "regex": '\m\[C03\d\d\]',
\ "file": ['\m^/usr/include/', '\m\c\.h$'] }
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 consist of a single
element you can omit adding the brackets (e.g. you can write "style" instead of
["style"]).
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" - is matched against the messages' text as a case insensitive
|regular-expression|
"file" - is matched against the filename the error refers to, as a case
sensitive |regular-expression|.
"file" - 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'*
Default: [Syntax: line:%F (%t)]
Use this option to control what the syntastic statusline text contains. Several
@ -467,6 +581,12 @@ statusline: >
<
If the buffer had 2 warnings, starting on line 5 then this would appear: >
[Warn: 5 #2]
<
*'b:syntastic_skip_checks'*
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'*
Default: 0 in GUI Vim and MacVim, 1 otherwise
@ -475,16 +595,24 @@ 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'*
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_debug'*
Default: 0
Set this to the sum of one or more of the following flags to enable
debugging:
1 - trace checker calls
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
@ -504,7 +632,7 @@ 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' ]
let g:syntastic_extra_filetypes = [ "make", "gitcommit" ]
<
This will allow |:SyntasticInfo| to do proper tab completion for the new
filetypes.
@ -518,14 +646,14 @@ filetypes.
*'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']
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
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
@ -541,48 +669,61 @@ Use |:SyntasticInfo| to see which checkers are available for a given filetype.
------------------------------------------------------------------------------
5.2 Choosing the executable *syntastic-config-exec*
*'syntastic_<filetype>_<subchecker>_exec'*
The executable used by a checker is normally defined automatically, when the
checkers is registered. You can however override it by setting the variable
'g:syntastic_<filetype>_<subchecker>_exec': >
*'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'*
And 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*
Most checkers use the 'makeprgBuild()' function and provide many options by
default - in fact you can customise every part of the command that gets called.
*'syntastic_<filetype>_<subchecker>_<option>'*
*'syntastic_<filetype>_<checker>_<option>'*
Checkers that use 'makeprgBuild()' construct a 'makeprg' like this: >
let makeprg = self.makeprgBuild({
\ 'exe': self.getExec(),
\ 'args': '-a -b -c',
\ 'post_args': '--more --args',
\ 'tail': '> /tmp/output' })
\ "exe": self.getExec(),
\ "args": "-a -b -c",
\ "post_args": "--more --args",
\ "tail": "2>/dev/null" })
<
The result is a 'makeprg' of the form: >
<exe> <args> <filename> <post_args> <tail>
<exe> <args> <fname> <post_args> <tail>
<
*'syntastic_<filetype>_<subchecker>_exe'*
All arguments above are optional, and can be overridden by setting global
variables 'g:syntastic_<filetype>_<checker-name>_<option-name>' - even
parameters not specified in the call to makeprgBuild(). These variables also
have local versions 'b:syntastic_<filetype>_<checker-name>_<option-name>',
which take precedence over the global ones in the corresponding buffers.
If one of these 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' is normally the same as the 'exec' attribute described above, in
which case it may be omitted. However, you can use it to add environment
variables or additional parameters, e.g. to tell the mri checker to use KANJI
encoding you could do something like this: >
let g:syntastic_ruby_mri_exe = 'RUBYOPT="-Ke" ruby'
variables, or to change the way the checker is run. For example this setup
allows you to run PC-Lint under Wine emulation on Linux: >
let g:syntastic_c_pc_lint_exec = "wine"
let g:syntastic_c_pc_lint_exe = "wine c:/path/to/lint-nt.exe"
<
To override the args and the tail: >
let g:syntastic_ruby_mri_args = "--my --args --here"
let g:syntastic_ruby_mri_tail = "> /tmp/my-output-file-biatch"
let g:syntastic_c_pc_lint_args = "-w5 -Iz:/usr/include/linux"
let g:syntastic_c_pc_lint_tail = "2>/dev/null"
<
The general form of the override options is: >
syntastic_<filetype>_<subchecker>_<option-name>
syntastic_<filetype>_<checker>_<option-name>
<
For checkers that do not use the 'makeprgBuild()' function you will have to
look at the source code of the checker in question. If there are specific
@ -594,48 +735,96 @@ options that can be set, these are usually documented in the wiki:
In the same vein, 'g:syntastic_<filetype>_<checker-name>_quiet_messages' can
be used to restrict message filters to messages produced by specific checkers.
Example: >
let g:syntastic_python_pylama_quiet_messages = { "type": "style",
\ "regex": '\m\[C03\d\d\]' }
let g:syntastic_python_pylama_quiet_messages = {
\ "type": "style",
\ "regex": '\m\[C03\d\d\]' }
<
See |syntastic_quiet_messages| for the syntax.
------------------------------------------------------------------------------
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).
==============================================================================
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
Some Vim plugins use composite filetypes, such as "django.python" or
"handlebars.html". Normally, syntastic deals with this situation by splitting
the filetype in its simple components, and calling all checkers that apply.
If this behaviour is not desirable, you can disable it by mapping the
composite filetypes to a simple ones using |syntastic_filetype_map|, e.g.: >
let g:syntastic_filetype_map = { 'handlebars.html': 'handlebars' }
let g:syntastic_filetype_map = { "handlebars.html": "handlebars" }
<
------------------------------------------------------------------------------
6.2 Interaction with python-mode *syntastic-pymode*
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 Interaction with python-mode *syntastic-pymode*
Syntastic can be used along with the 'python-mode' Vim plugin (see
https://github.com/klen/python-mode). However, they both run syntax checks by
default when you save buffers to disk, and this is probably not what you want.
To avoid both plugins opening error windows, you can either set passive mode
for python in syntastic (see |syntastic_mode_map|), or disable lint checks in
python-mode, by setting |pymode_lint_write| to 0. E.g.: >
'python-mode', by setting |pymode_lint_write| to 0. E.g.: >
let g:pymode_lint_write = 0
<
------------------------------------------------------------------------------
6.3 Interaction with the fish shell *syntastic-fish*
6.4 Interaction with 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 |ycm_show_diagnostics_ui| to 0. E.g.: >
let g:ycm_show_diagnostics_ui = 0
<
------------------------------------------------------------------------------
6.5 Interaction with the fish shell *syntastic-fish*
At the time of this writing the 'fish' shell (see http://fishshell.com/)
doesn't support the standard UNIX syntax for file redirections, and thus it
can't be used together with syntastic. You don't need to change your login
shell to address this problem, but you do have to point Vim's 'shell' to a more
traditional shell, such as 'zsh', 'bash', 'ksh', or even the original Bourne
'sh': >
traditional shell, such as "zsh", "bash", "ksh", or even the original Bourne
"sh": >
set shell=bash
<
------------------------------------------------------------------------------
6.4. Using syntastic with the fizsh shell *syntastic-fizsh*
6.6. Interaction with PowerShell *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
<
------------------------------------------------------------------------------
6.7. Using syntastic with the fizsh shell *syntastic-fizsh*
Using syntastic with the 'fizsh' shell (see https://github.com/zsh-users/fizsh)
is possible, but potentially problematic. In order to do it you'll need to set
@ -643,17 +832,51 @@ is possible, but potentially problematic. In order to do it you'll need to set
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: >
interactive features of 'fizsh'. Using a more traditional shell such as "zsh",
"bash", "ksh", or the original Bourne "sh" might be a better choice: >
set shell=zsh
<
------------------------------------------------------------------------------
6.8. Interaction with 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.
------------------------------------------------------------------------------
6.9. Interaction with 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'.
------------------------------------------------------------------------------
6.10. Interaction with vim-auto-save *syntastic-vim-auto-save*
At the time of this writing, syntastic checks in active mode are not triggered
by 'vim-auto-save' (see https://github.com/907th/vim-auto-save). The reason is
a limitation in 'vim-auto-save', namely a missing flag to an 'autocmd' (see
|autocmd-nested|). Fortunately it's pretty easy to achieve a similar effect
without 'vim-auto-save'': >
augroup syntastic
autocmd CursorHold * nested update
augroup END
set updatetime=200
<
==============================================================================
7. About *syntastic-about*
The core maintainers of syntastic are:
Martin Grenfell (github: scrooloose)
Gregor Uhlenheuer (github: kongo2002)
LCD 047 (github: lcd047)
Martin Grenfell (GitHub: scrooloose)
Gregor Uhlenheuer (GitHub: kongo2002)
LCD 047 (GitHub: lcd047)
Find the latest version of syntastic at:

@ -1,7 +1,6 @@
"============================================================================
"File: syntastic.vim
"Description: Vim plugin for on the fly syntax checking.
"Version: 3.4.0-pre
"License: This program is free software. It comes without any warranty,
" to the extent permitted by applicable law. You can redistribute
" it and/or modify it under the terms of the Do What The Fuck You
@ -16,85 +15,87 @@ endif
let g:loaded_syntastic_plugin = 1
if has('reltime')
let g:syntastic_start = reltime()
let g:_SYNTASTIC_START = reltime()
lockvar! g:_SYNTASTIC_START
endif
runtime! plugin/syntastic/*.vim
let g:_SYNTASTIC_VERSION = '3.6.0-5'
lockvar g:_SYNTASTIC_VERSION
let s:running_windows = syntastic#util#isRunningWindows()
" Sanity checks {{{1
for s:feature in ['autocmd', 'eval', 'modify_fname', 'quickfix', 'user_commands']
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
if !s:running_windows && executable('uname')
let s:_running_windows = syntastic#util#isRunningWindows()
lockvar s:_running_windows
if !s:_running_windows && executable('uname')
try
let s:uname = system('uname')
catch /^Vim\%((\a\+)\)\=:E484/
call syntastic#log#error("your shell " . &shell . " doesn't use traditional UNIX syntax for redirections")
let s:_uname = system('uname')
catch /\m^Vim\%((\a\+)\)\=:E484/
call syntastic#log#error("your shell " . &shell . " can't handle traditional UNIX syntax for redirections")
finish
endtry
lockvar s:_uname
endif
if !exists("g:syntastic_always_populate_loc_list")
let g:syntastic_always_populate_loc_list = 0
endif
if !exists("g:syntastic_auto_jump")
let g:syntastic_auto_jump = 0
endif
if !exists("g:syntastic_quiet_messages")
let g:syntastic_quiet_messages = {}
endif
if !exists("g:syntastic_stl_format")
let g:syntastic_stl_format = '[Syntax: line:%F (%t)]'
endif
if !exists("g:syntastic_check_on_open")
let g:syntastic_check_on_open = 0
endif
if !exists("g:syntastic_check_on_wq")
let g:syntastic_check_on_wq = 1
endif
if !exists("g:syntastic_aggregate_errors")
let g:syntastic_aggregate_errors = 0
endif
if !exists("g:syntastic_id_checkers")
let g:syntastic_id_checkers = 1
endif
if !exists("g:syntastic_loc_list_height")
let g:syntastic_loc_list_height = 10
endif
if !exists("g:syntastic_ignore_files")
let g:syntastic_ignore_files = []
endif
if !exists("g:syntastic_filetype_map")
let g:syntastic_filetype_map = {}
endif
if !exists("g:syntastic_full_redraws")
let g:syntastic_full_redraws = !(has('gui_running') || has('gui_macvim'))
endif
" TODO: not documented
if !exists("g:syntastic_reuse_loc_lists")
" a relevant bug has been fixed in one of the pre-releases of Vim 7.4
let g:syntastic_reuse_loc_lists = (v:version >= 704)
endif
" }}}1
" Defaults {{{1
let g:_SYNTASTIC_DEFAULTS = {
\ 'aggregate_errors': 0,
\ 'always_populate_loc_list': 0,
\ 'auto_jump': 0,
\ 'auto_loc_list': 2,
\ 'bash_hack': 0,
\ '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 && &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,
\ 'quiet_messages': {},
\ 'reuse_loc_lists': 0,
\ '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#deprecationWarn("variable g:syntastic_quiet_warnings is deprecated, please use let g:syntastic_quiet_messages = {'level': 'warnings'} instead")
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([])
@ -105,7 +106,11 @@ if exists("g:syntastic_quiet_warnings")
endif
endif
let s:debug_dump_options = [
" }}}1
" Debug {{{1
let s:_DEBUG_DUMP_OPTIONS = [
\ 'shell',
\ 'shellcmdflag',
\ 'shellpipe',
@ -116,34 +121,44 @@ let s:debug_dump_options = [
\ 'shellxquote'
\ ]
if v:version > 703 || (v:version == 703 && has('patch446'))
call add(s:debug_dump_options, 'shellxescape')
call add(s:_DEBUG_DUMP_OPTIONS, 'shellxescape')
endif
lockvar! s:_DEBUG_DUMP_OPTIONS
" debug constants
let g:SyntasticDebugTrace = 1
let g:SyntasticDebugLoclist = 2
let g:SyntasticDebugNotifications = 4
let g:SyntasticDebugAutocommands = 8
let g:SyntasticDebugVariables = 16
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()
" Commands {{{1
" @vimlint(EVL103, 1, a:cursorPos)
" @vimlint(EVL103, 1, a:cmdLine)
" @vimlint(EVL103, 1, a:argLead)
function! s:CompleteCheckerName(argLead, cmdLine, cursorPos)
function! s:CompleteCheckerName(argLead, cmdLine, cursorPos) " {{{2
let checker_names = []
for ft in s:ResolveFiletypes()
for checker in s:registry.availableCheckersFor(ft)
call add(checker_names, checker.getName())
endfor
for ft in s:_resolve_filetypes([])
call extend(checker_names, s:registry.getNamesOfAvailableCheckers(ft))
endfor
return join(checker_names, "\n")
endfunction
endfunction " }}}2
" @vimlint(EVL103, 0, a:cursorPos)
" @vimlint(EVL103, 0, a:cmdLine)
" @vimlint(EVL103, 0, a:argLead)
@ -152,36 +167,63 @@ endfunction
" @vimlint(EVL103, 1, a:cursorPos)
" @vimlint(EVL103, 1, a:cmdLine)
" @vimlint(EVL103, 1, a:argLead)
function! s:CompleteFiletypes(argLead, cmdLine, cursorPos)
return join(s:registry.knownFiletypes(), "\n")
endfunction
function! s:CompleteFiletypes(argLead, cmdLine, cursorPos) " {{{2
return join(s:registry.getKnownFiletypes(), "\n")
endfunction " }}}2
" @vimlint(EVL103, 0, a:cursorPos)
" @vimlint(EVL103, 0, a:cmdLine)
" @vimlint(EVL103, 0, a:argLead)
command! -nargs=* -complete=custom,s:CompleteCheckerName SyntasticCheck call SyntasticCheck(<f-args>)
command! -nargs=? -complete=custom,s:CompleteFiletypes SyntasticInfo call SyntasticInfo(<f-args>)
command! Errors call SyntasticErrors()
command! SyntasticReset call SyntasticReset()
command! SyntasticToggleMode call SyntasticToggleMode()
command! SyntasticSetLoclist call SyntasticSetLoclist()
command! SyntasticToggleMode call s:ToggleMode()
command! -nargs=* -complete=custom,s:CompleteCheckerName SyntasticCheck
\ call s:UpdateErrors(0, <f-args>) <bar>
\ call syntastic#util#redraw(g:syntastic_full_redraws)
command! Errors call s:ShowLocList()
command! -nargs=? -complete=custom,s:CompleteFiletypes SyntasticInfo
\ call s:modemap.echoMode() |
\ call s:registry.echoInfoFor(s:ResolveFiletypes(<f-args>))
command! SyntasticReset
\ call s:ClearCache() |
\ call s:notifiers.refresh(g:SyntasticLoclist.New([]))
command! SyntasticSetLoclist call g:SyntasticLoclist.current().setloclist()
" }}}1
augroup syntastic
autocmd BufReadPost * call s:BufReadPostHook()
autocmd BufWritePost * call s:BufWritePostHook()
" Public API {{{1
function! SyntasticCheck(...) " {{{2
call s:UpdateErrors(0, a:000)
call syntastic#util#redraw(g:syntastic_full_redraws)
endfunction " }}}2
autocmd BufWinEnter * call s:BufWinEnterHook()
function! SyntasticInfo(...) " {{{2
call s:modemap.modeInfo(a:000)
call s:registry.echoInfoFor(s:_resolve_filetypes(a:000))
call s:_explain_skip(a:000)
endfunction " }}}2
" TODO: the next autocmd should be "autocmd BufWinLeave * if &buftype == '' | lclose | endif"
" but in recent versions of Vim lclose can no longer be called from BufWinLeave
autocmd BufEnter * call s:BufEnterHook()
function! SyntasticErrors() " {{{2
call g:SyntasticLoclist.current().show()
endfunction " }}}2
function! SyntasticReset() " {{{2
call s:ClearCache()
call s:notifiers.refresh(g:SyntasticLoclist.New([]))
endfunction " }}}2
function! SyntasticToggleMode() " {{{2
call s:modemap.toggleMode()
call s:ClearCache()
call s:notifiers.refresh(g:SyntasticLoclist.New([]))
call s:modemap.echoMode()
endfunction " }}}2
function! SyntasticSetLoclist() " {{{2
call g:SyntasticLoclist.current().setloclist()
endfunction " }}}2
" }}}1
" Autocommands {{{1
augroup syntastic
autocmd BufReadPost * call s:BufReadPostHook()
autocmd BufWritePost * call s:BufWritePostHook()
autocmd BufEnter * call s:BufEnterHook()
augroup END
if v:version > 703 || (v:version == 703 && has('patch544'))
@ -191,78 +233,93 @@ if v:version > 703 || (v:version == 703 && has('patch544'))
augroup END
endif
function! s:BufReadPostHook()
function! s:BufReadPostHook() " {{{2
if g:syntastic_check_on_open
call syntastic#log#debug(g:SyntasticDebugAutocommands,
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_AUTOCOMMANDS,
\ 'autocmd: BufReadPost, buffer ' . bufnr("") . ' = ' . string(bufname(str2nr(bufnr("")))))
call s:UpdateErrors(1)
call s:UpdateErrors(1, [])
endif
endfunction
endfunction " }}}2
function! s:BufWritePostHook()
call syntastic#log#debug(g:SyntasticDebugAutocommands,
function! s:BufWritePostHook() " {{{2
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_AUTOCOMMANDS,
\ 'autocmd: BufWritePost, buffer ' . bufnr("") . ' = ' . string(bufname(str2nr(bufnr("")))))
call s:UpdateErrors(1)
endfunction
call s:UpdateErrors(1, [])
endfunction " }}}2
function! s:BufWinEnterHook()
call syntastic#log#debug(g:SyntasticDebugAutocommands,
\ 'autocmd: BufWinEnter, buffer ' . bufnr("") . ' = ' . string(bufname(str2nr(bufnr("")))) .
function! s:BufEnterHook() " {{{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 get(w:, 'syntastic_loclist_set', 0) && !empty(loclist) && empty(filter( buffers, 'syntastic#util#bufIsActive(v:val)' ))
call SyntasticLoclistHide()
endif
endif
endfunction
endfunction " }}}2
function! s:BufEnterHook()
call syntastic#log#debug(g:SyntasticDebugAutocommands,
\ 'autocmd: BufEnter, buffer ' . bufnr("") . ' = ' . string(bufname(str2nr(bufnr("")))) .
\ ', &buftype = ' . string(&buftype))
" TODO: at this point there is no b:syntastic_loclist
let loclist = filter(getloclist(0), 'v:val["valid"] == 1')
let buffers = syntastic#util#unique(map( loclist, 'v:val["bufnr"]' ))
if &buftype == 'quickfix' && !empty(loclist) && empty(filter( buffers, 'syntastic#util#bufIsActive(v:val)' ))
call g:SyntasticLoclistHide()
function! s:QuitPreHook() " {{{2
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_AUTOCOMMANDS,
\ 'autocmd: QuitPre, buffer ' . bufnr("") . ' = ' . string(bufname(str2nr(bufnr("")))))
let b:syntastic_skip_checks = get(b:, 'syntastic_skip_checks', 0) || !syntastic#util#var('check_on_wq')
if get(w:, 'syntastic_loclist_set', 0)
call SyntasticLoclistHide()
endif
endfunction
endfunction " }}}2
function! s:QuitPreHook()
call syntastic#log#debug(g:SyntasticDebugAutocommands,
\ 'autocmd: QuitPre, buffer ' . bufnr("") . ' = ' . string(bufname(str2nr(bufnr("")))))
let b:syntastic_skip_checks = !g:syntastic_check_on_wq
call g:SyntasticLoclistHide()
endfunction
" }}}1
" Main {{{1
"refresh and redraw all the error info for this buf when saving or reading
function! s:UpdateErrors(auto_invoked, ...)
if s:SkipFile()
function! s:UpdateErrors(auto_invoked, checker_names) " {{{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'))
if s:_skip_file()
return
endif
call s:modemap.synch()
let run_checks = !a:auto_invoked || s:modemap.allowsAutoChecking(&filetype)
let run_checks = !a:auto_invoked || s:modemap.doAutoChecking()
if run_checks
call s:CacheErrors(a:000)
call s:CacheErrors(a:checker_names)
endif
let loclist = g:SyntasticLoclist.current()
let w:syntastic_loclist_set = 0
let do_jump = g:syntastic_auto_jump
if g:syntastic_auto_jump == 2
let first = loclist.getFirstIssue()
let type = get(first, 'type', '')
let do_jump = type ==? 'E'
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
if g:syntastic_always_populate_loc_list || do_jump
call syntastic#log#debug(g:SyntasticDebugNotifications, 'loclist: setloclist (new)')
let w:syntastic_loclist_set = 0
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())
let w:syntastic_loclist_set = 1
if run_checks && do_jump && !loclist.isEmpty()
call syntastic#log#debug(g:SyntasticDebugNotifications, 'loclist: jump')
silent! lrewind
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
@ -273,150 +330,108 @@ function! s:UpdateErrors(auto_invoked, ...)
endif
endif
endif
" }}}3
call s:notifiers.refresh(loclist)
endfunction
endfunction " }}}2
"clear the loc list for the buffer
function! s:ClearCache()
function! s:ClearCache() " {{{2
call s:notifiers.reset(g:SyntasticLoclist.current())
unlet! b:syntastic_loclist
endfunction
function! s:ResolveFiletypes(...)
let type = a:0 ? a:1 : &filetype
return split( get(g:syntastic_filetype_map, type, type), '\m\.' )
endfunction
call b:syntastic_loclist.destroy()
endfunction " }}}2
"detect and cache all syntax errors in this buffer
function! s:CacheErrors(checkers)
function! s:CacheErrors(checker_names) " {{{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:SkipFile()
let active_checkers = 0
let names = []
if !s:_skip_file()
" debug logging {{{3
call syntastic#log#debugShowVariables(g:_SYNTASTIC_DEBUG_TRACE, 'aggregate_errors')
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_TRACE, 'getcwd() = ' . getcwd())
" }}}3
call syntastic#log#debugShowOptions(g:SyntasticDebugTrace, s:debug_dump_options)
call syntastic#log#debugDump(g:SyntasticDebugVariables)
call syntastic#log#debugShowVariables(g:SyntasticDebugTrace, 'syntastic_aggregate_errors')
call syntastic#log#debug(g:SyntasticDebugTrace, 'getcwd() = ' . getcwd())
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 filetypes = s:ResolveFiletypes()
let aggregate_errors = syntastic#util#var('aggregate_errors')
let decorate_errors = (aggregate_errors || len(filetypes) > 1) && syntastic#util#var('id_checkers')
let clist = []
for type in filetypes
call extend(clist, s:registry.getCheckers(type, a:checker_names))
endfor
for ft in filetypes
let clist = empty(a:checkers) ? s:registry.getActiveCheckers(ft) : s:registry.getCheckers(ft, a:checkers)
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
for checker in clist
let active_checkers += 1
call syntastic#log#debug(g:SyntasticDebugTrace, 'CacheErrors: Invoking checker: ' . checker.getName())
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_TRACE, 'CacheErrors: Invoking checker: ' . cname)
let loclist = checker.getLocList()
let loclist = checker.getLocList()
if !loclist.isEmpty()
if decorate_errors
call loclist.decorate(checker.getName(), checker.getFiletype())
endif
call add(names, [checker.getName(), checker.getFiletype()])
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)
let newLoclist = newLoclist.extend(loclist)
if !aggregate_errors
break
endif
if !aggregate_errors
break
endif
endfor
endif
endfor
" set names {{{3
if !empty(names)
if len(syntastic#util#unique(map(copy(names), 'v:val[1]'))) == 1
let type = names[0][1]
let name = join(map(names, 'v:val[0]'), ', ')
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(map(names, 'v:val[1] . "/" . v:val[0]'), ', '))
call newLoclist.setName(join(names, ', '))
endif
endif
" }}}3
if !active_checkers
if !empty(a:checkers)
if len(a:checkers) == 1
call syntastic#log#warn('checker ' . a:checkers[0] . ' is not active for filetype ' . &filetype)
" 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:checkers, ', ') . ' are not active for filetype ' . &filetype)
call syntastic#log#warn('checkers ' . join(a:checker_names, ', ') . ' are not available')
endif
else
call syntastic#log#debug(g:SyntasticDebugTrace, 'CacheErrors: no active checkers for filetype ' . &filetype)
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_TRACE, 'CacheErrors: no checkers available for ' . &filetype)
endif
endif
" }}}3
call syntastic#log#debug(g:SyntasticDebugLoclist, 'aggregated:', newLoclist)
if type(g:syntastic_quiet_messages) == type({}) && !empty(g:syntastic_quiet_messages)
call newLoclist.quietMessages(g:syntastic_quiet_messages)
call syntastic#log#debug(g:SyntasticDebugLoclist, 'filtered by g:syntastic_quiet_messages:', newLoclist)
endif
endif
let b:syntastic_loclist = newLoclist
endfunction
function! s:ToggleMode()
call s:modemap.toggleMode()
call s:ClearCache()
call s:UpdateErrors(1)
call s:modemap.echoMode()
endfunction
"display the cached errors for this buf in the location list
function! s:ShowLocList()
call g:SyntasticLoclist.current().show()
endfunction
"the script changes &shellredir and &shell to stop the screen flicking when
"shelling out to syntax checkers. Not all OSs support the hacks though
function! s:OSSupportsShellredirHack()
return !s:running_windows && executable('/bin/bash') && (s:uname() !~ "FreeBSD") && (s:uname() !~ "OpenBSD")
endfunction
function! s:IsRedrawRequiredAfterMake()
return !s:running_windows && (s:uname() =~ "FreeBSD" || s:uname() =~ "OpenBSD")
endfunction
function! s:IgnoreFile(filename)
let fname = fnamemodify(a:filename, ':p')
for pattern in g:syntastic_ignore_files
if fname =~# pattern
return 1
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
endfor
return 0
endfunction
" Skip running in special buffers
function! s:SkipFile()
let force_skip = exists('b:syntastic_skip_checks') ? b:syntastic_skip_checks : 0
let fname = expand('%')
return force_skip || (&buftype != '') || !filereadable(fname) || getwinvar(0, '&diff') || s:IgnoreFile(fname)
endfunction
function! s:uname()
if !exists('s:uname')
let s:uname = system('uname')
endif
return s:uname
endfunction
"return a string representing the state of buffer according to
"g:syntastic_stl_format
"
"return '' if no errors are cached for the buffer
function! SyntasticStatuslineFlag()
return g:SyntasticLoclist.current().getStatuslineFlag()
endfunction
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
@ -434,24 +449,22 @@ endfunction
" '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
function! SyntasticMake(options)
call syntastic#log#debug(g:SyntasticDebugTrace, 'SyntasticMake: called with options:', a:options)
" @vimlint(EVL102, 1, l:env_save)
function! SyntasticMake(options) " {{{2
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_TRACE, 'SyntasticMake: called with options:', a:options)
let old_shell = &shell
" save options and locale env variables {{{3
let old_shellredir = &shellredir
let old_local_errorformat = &l:errorformat
let old_errorformat = &errorformat
let old_cwd = getcwd()
let old_lc_messages = $LC_MESSAGES
let old_lc_all = $LC_ALL
" }}}3
if s:OSSupportsShellredirHack()
"this is a hack to stop the screen needing to be ':redraw'n when
"when :lmake is run. Otherwise the screen flickers annoyingly
let &shellredir = '&>'
let &shell = '/bin/bash'
endif
call s:_bash_hack()
if has_key(a:options, 'errorformat')
let &errorformat = a:options['errorformat']
@ -461,63 +474,180 @@ function! SyntasticMake(options)
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_]\+$'
exec 'let env_save[' . string(key) . '] = $' . key
exec 'let $' . key . ' = ' . string(a:options['env'][key])
endif
endfor
endif
let $LC_MESSAGES = 'C'
let $LC_ALL = ''
" }}}3
let err_lines = split(system(a:options['makeprg']), "\n", 1)
" restore environment variables {{{3
let $LC_ALL = old_lc_all
let $LC_MESSAGES = old_lc_messages
call syntastic#log#debug(g:SyntasticDebugLoclist, 'checker output:', err_lines)
if has_key(a:options, 'preprocess')
let err_lines = call(a:options['preprocess'], [err_lines])
call syntastic#log#debug(g:SyntasticDebugLoclist, 'preprocess:', err_lines)
if len(env_save)
for key in keys(env_save)
exec 'let $' . key . ' = ' . string(env_save[key])
endfor
endif
lgetexpr err_lines
" }}}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 = copy(getloclist(0))
let errors = deepcopy(getloclist(0))
if has_key(a:options, 'cwd')
execute 'lcd ' . fnameescape(old_cwd)
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
silent! lolder
" restore options {{{3
let &errorformat = old_errorformat
let &l:errorformat = old_local_errorformat
let &shellredir = old_shellredir
let &shell = old_shell
" }}}3
if s:IsRedrawRequiredAfterMake()
if !s:_running_windows && (s:_os_name() =~ "FreeBSD" || s:_os_name() =~ "OpenBSD")
call syntastic#util#redraw(g:syntastic_full_redraws)
endif
call syntastic#log#debug(g:SyntasticDebugLoclist, 'raw loclist:', errors)
if has_key(a:options, 'returns') && index(a:options['returns'], v:shell_error) == -1
if bailout
throw 'Syntastic: checker error'
endif
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_LOCLIST, 'raw loclist:', errors)
if has_key(a:options, 'defaults')
call SyntasticAddToErrors(errors, 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 SyntasticAddToErrors(errors, { 'subtype': a:options['subtype'] })
call s:_add_to_errors(errors, { 'subtype': a:options['subtype'] })
endif
if has_key(a:options, 'postprocess') && !empty(a:options['postprocess'])
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:SyntasticDebugLoclist, 'postprocess:', errors)
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_LOCLIST, 'postprocess:', errors)
endif
return errors
endfunction
endfunction " }}}2
" @vimlint(EVL102, 0, l:env_save)
"take a list of errors and add default values to them from a:options
function! SyntasticAddToErrors(errors, options)
"return a string representing the state of buffer according to
"g:syntastic_stl_format
"
"return '' if no errors are cached for the buffer
function! SyntasticStatuslineFlag() " {{{2
return g:SyntasticLoclist.current().getStatuslineFlag()
endfunction " }}}2
" }}}1
" Utilities {{{1
function! s:_resolve_filetypes(filetypes) " {{{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) " {{{2
let fname = fnamemodify(a:filename, ':p')
for pattern in g:syntastic_ignore_files
if fname =~# pattern
return 1
endif
endfor
return 0
endfunction " }}}2
" Skip running in special buffers
function! s:_skip_file() " {{{2
let fname = expand('%', 1)
let skip = get(b:, 'syntastic_skip_checks', 0) || (&buftype != '') ||
\ !filereadable(fname) || getwinvar(0, '&diff') || 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) " {{{2
if empty(a:filetypes) && s:_skip_file()
let why = []
let fname = expand('%', 1)
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 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) " {{{2
for err in a:errors
for key in keys(a:options)
if !has_key(err, key) || empty(err[key])
@ -527,6 +657,34 @@ function! SyntasticAddToErrors(errors, options)
endfor
return a:errors
endfunction
endfunction " }}}2
" XXX: Is this still needed?
" The script changes &shellredir to stop the screen
" flicking when shelling out to syntax checkers.
function! s:_bash_hack() " {{{2
if g:syntastic_bash_hack
if !exists('s:shell_is_bash')
let s:shell_is_bash =
\ !s:_running_windows &&
\ (s:_os_name() !~# "FreeBSD") && (s:_os_name() !~# "OpenBSD") &&
\ &shell =~# '\m\<bash$'
endif
if s:shell_is_bash
let &shellredir = '&>'
endif
endif
endfunction " }}}2
function! s:_os_name() " {{{2
if !exists('s:_uname')
let s:_uname = system('uname')
lockvar s:_uname
endif
return s:_uname
endfunction " }}}2
" }}}1
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

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

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

@ -1,4 +1,4 @@
if exists("g:loaded_syntastic_checker")
if exists("g:loaded_syntastic_checker") || !exists("g:loaded_syntastic_plugin")
finish
endif
let g:loaded_syntastic_checker = 1
@ -7,7 +7,7 @@ let g:SyntasticChecker = {}
" Public methods {{{1
function! g:SyntasticChecker.New(args)
function! g:SyntasticChecker.New(args) " {{{2
let newObj = copy(self)
let newObj._filetype = a:args['filetype']
@ -17,6 +17,10 @@ function! g:SyntasticChecker.New(args)
if has_key(a:args, 'redirect')
let [filetype, name] = split(a:args['redirect'], '/')
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
else
let prefix = 'SyntaxCheckers_' . newObj._filetype . '_' . newObj._name . '_'
endif
@ -26,7 +30,7 @@ function! g:SyntasticChecker.New(args)
if exists('*' . prefix . 'IsAvailable')
let newObj._isAvailableFunc = function(prefix . 'IsAvailable')
else
let newObj._isAvailableFunc = function('SyntasticCheckerIsAvailableDefault')
let newObj._isAvailableFunc = function('s:_isAvailableDefault')
endif
if exists('*' . prefix . 'GetHighlightRegex')
@ -34,48 +38,77 @@ function! g:SyntasticChecker.New(args)
endif
return newObj
endfunction
endfunction " }}}2
function! g:SyntasticChecker.getFiletype()
function! g:SyntasticChecker.getFiletype() " {{{2
return self._filetype
endfunction
endfunction " }}}2
function! g:SyntasticChecker.getName()
function! g:SyntasticChecker.getName() " {{{2
return self._name
endfunction
function! g:SyntasticChecker.getExec()
if exists('g:syntastic_' . self._filetype . '_' . self._name . '_exec')
return expand(g:syntastic_{self._filetype}_{self._name}_exec)
endif
endfunction " }}}2
return self._exec
endfunction
function! g:SyntasticChecker.getExec() " {{{2
return
\ expand( exists('b:syntastic_' . self._name . '_exec') ? b:syntastic_{self._name}_exec :
\ syntastic#util#var(self._filetype . '_' . self._name . '_exec', self._exec), 1 )
endfunction " }}}2
function! g:SyntasticChecker.getExecEscaped()
function! g:SyntasticChecker.getExecEscaped() " {{{2
return syntastic#util#shescape(self.getExec())
endfunction
endfunction " }}}2
function! g:SyntasticChecker.getLocListRaw()
function! g:SyntasticChecker.getLocListRaw() " {{{2
let name = self._filetype . '/' . self._name
try
let list = self._locListFunc()
call syntastic#log#debug(g:SyntasticDebugTrace, 'getLocList: checker ' . name . ' returned ' . v:shell_error)
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_TRACE, 'getLocList: checker ' . name . ' returned ' . v:shell_error)
catch /\m\C^Syntastic: checker error$/
let list = []
call syntastic#log#error('checker ' . name . ' returned abnormal status ' . v:shell_error)
endtry
call self._populateHighlightRegexes(list)
call syntastic#log#debug(g:SyntasticDebugLoclist, name . ' raw:', list)
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_LOCLIST, name . ' raw:', list)
call self._quietMessages(list)
return list
endfunction
endfunction " }}}2
function! g:SyntasticChecker.getLocList()
function! g:SyntasticChecker.getLocList() " {{{2
return g:SyntasticLoclist.New(self.getLocListRaw())
endfunction
endfunction " }}}2
function! g:SyntasticChecker.getVersion(...) " {{{2
if !exists('self._version')
let command = a:0 ? a:1 : self.getExecEscaped() . ' --version'
let version_output = system(command)
call syntastic#log#debug( g:_SYNTASTIC_DEBUG_CHECKERS,
\ self._filetype . '/' . self._name . ': output of ' . string(command) . ': ' .
\ string(split(version_output, "\n", 1)) .
\ (v:shell_error ? ' (exit code ' . v:shell_error . ')' : '') )
call self.setVersion(syntastic#util#parseVersion(version_output))
endif
return get(self, '_version', [])
endfunction " }}}2
function! g:SyntasticChecker.makeprgBuild(opts)
function! g:SyntasticChecker.setVersion(version) " {{{2
if len(a:version)
let self._version = copy(a:version)
call self.log(self.getExec() . ' version =', a:version)
else
call syntastic#log#error("checker " . self._filetype . "/" . self._name . ": can't parse version string (abnormal termination?)")
endif
endfunction " }}}2
function! g:SyntasticChecker.log(msg, ...) " {{{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) " {{{2
let basename = self._filetype . '_' . self._name . '_'
let parts = []
@ -86,59 +119,86 @@ function! g:SyntasticChecker.makeprgBuild(opts)
call extend(parts, self._getOpt(a:opts, basename, 'tail', ''))
return join(parts)
endfunction
endfunction " }}}2
function! g:SyntasticChecker.isAvailable() " {{{2
if !has_key(self, '_available')
let self._available = self._isAvailableFunc()
endif
return self._available
endfunction " }}}2
function! g:SyntasticChecker.wantSort() " {{{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) " {{{2
if !exists('g:syntastic_' . self._filetype . '_' . self._name . '_sort')
let g:syntastic_{self._filetype}_{self._name}_sort = a:val
endif
endfunction " }}}2
function! g:SyntasticChecker.isAvailable()
return self._isAvailableFunc()
endfunction
" }}}1
" Private methods {{{1
function! g:SyntasticChecker._quietMessages(errors)
let filter = 'g:syntastic_' . self._filetype . '_' . self._name . '_quiet_messages'
if exists(filter) && type({filter}) == type({}) && !empty({filter})
call syntastic#util#dictFilter(a:errors, {filter})
call syntastic#log#debug(g:SyntasticDebugLoclist, 'filtered by ' . filter . ':', a:errors)
function! g:SyntasticChecker._quietMessages(errors) " {{{2
" wildcard quiet_messages
let quiet_filters = copy(syntastic#util#var('quiet_messages', {}))
if type(quiet_filters) != type({})
call syntastic#log#warn('ignoring invalid syntastic_quiet_messages')
unlet quiet_filters
let quiet_filters = {}
endif
endfunction
function! g:SyntasticChecker._populateHighlightRegexes(errors)
" 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) " {{{2
if has_key(self, '_highlightRegexFunc')
for e in a:errors
if e['valid']
let term = self._highlightRegexFunc(e)
if len(term) > 0
if term != ''
let e['hl'] = term
endif
endif
endfor
endif
endfunction
endfunction " }}}2
function! g:SyntasticChecker._getOpt(opts, basename, name, default)
let user_val = syntastic#util#var(a:basename . a:name)
function! g:SyntasticChecker._getOpt(opts, basename, name, default) " {{{2
let ret = []
call extend( ret, self._shescape(get(a:opts, a:name . '_before', '')) )
call extend( ret, self._shescape(user_val != '' ? user_val : get(a:opts, a:name, a:default)) )
call extend( ret, self._shescape(get(a:opts, a:name . '_after', '')) )
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
endfunction " }}}2
function! g:SyntasticChecker._shescape(opt)
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
" }}}1
return []
endfunction
" Private functions {{{1
" Non-method functions {{{1
function! SyntasticCheckerIsAvailableDefault() dict
function! s:_isAvailableDefault() dict " {{{2
return executable(self.getExec())
endfunction
endfunction " }}}2
" }}}1
" vim: set sw=4 sts=4 et fdm=marker:

@ -1,67 +1,138 @@
if exists("g:loaded_syntastic_notifier_cursor")
if exists("g:loaded_syntastic_notifier_cursor") || !exists("g:loaded_syntastic_plugin")
finish
endif
let g:loaded_syntastic_notifier_cursor = 1
if !exists('g:syntastic_echo_current_error')
let g:syntastic_echo_current_error = 1
endif
let g:SyntasticCursorNotifier = {}
" Public methods {{{1
function! g:SyntasticCursorNotifier.New()
function! g:SyntasticCursorNotifier.New() " {{{2
let newObj = copy(self)
return newObj
endfunction
endfunction " }}}2
function! g:SyntasticCursorNotifier.enabled()
function! g:SyntasticCursorNotifier.enabled() " {{{2
return syntastic#util#var('echo_current_error')
endfunction
endfunction " }}}2
function! g:SyntasticCursorNotifier.refresh(loclist)
function! g:SyntasticCursorNotifier.refresh(loclist) " {{{2
if self.enabled() && !a:loclist.isEmpty()
call syntastic#log#debug(g:SyntasticDebugNotifications, 'cursor: refresh')
let b:syntastic_messages = copy(a:loclist.messages(bufnr('')))
let b:oldLine = -1
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 g:SyntasticRefreshCursor()
autocmd syntastic CursorMoved * call SyntasticRefreshCursor()
endif
endfunction
endfunction " }}}2
" @vimlint(EVL103, 1, a:loclist)
function! g:SyntasticCursorNotifier.reset(loclist)
call syntastic#log#debug(g:SyntasticDebugNotifications, 'cursor: reset')
function! g:SyntasticCursorNotifier.reset(loclist) " {{{2
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'cursor: reset')
autocmd! syntastic CursorMoved
unlet! b:syntastic_messages
let b:oldLine = -1
endfunction
unlet! b:syntastic_private_messages
let b:syntastic_private_line = -1
endfunction " }}}2
" @vimlint(EVL103, 0, a:loclist)
" Private methods {{{1
" }}}1
" Private functions {{{1
" The following defensive nonsense is needed because of the nature of autocmd
function! g:SyntasticRefreshCursor()
if !exists('b:syntastic_messages') || empty(b:syntastic_messages)
function! SyntasticRefreshCursor() " {{{2
if !exists('b:syntastic_private_messages') || empty(b:syntastic_private_messages)
" file not checked
return
endif
if !exists('b:oldLine')
let b:oldLine = -1
if !exists('b:syntastic_private_line')
let b:syntastic_private_line = -1
endif
let l = line('.')
if l == b:oldLine
return
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
let b:oldLine = l
if has_key(b:syntastic_messages, l)
call syntastic#util#wideMsg(b:syntastic_messages[l])
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
echo
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
endfunction " }}}2
" }}}1
" Utilities {{{1
function! s:_is_same_index(line, old_line, column, idx, messages) " {{{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) " {{{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:

@ -1,14 +1,11 @@
if exists("g:loaded_syntastic_notifier_highlighting")
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'))
if !exists("g:syntastic_enable_highlighting")
let g:syntastic_enable_highlighting = 1
endif
lockvar s:has_highlighting
let g:SyntasticHighlightingNotifier = {}
@ -16,30 +13,31 @@ let s:setup_done = 0
" Public methods {{{1
function! g:SyntasticHighlightingNotifier.New()
function! g:SyntasticHighlightingNotifier.New() " {{{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
endfunction " }}}2
function! g:SyntasticHighlightingNotifier.enabled()
function! g:SyntasticHighlightingNotifier.enabled() " {{{2
return s:has_highlighting && syntastic#util#var('enable_highlighting')
endfunction
endfunction " }}}2
" Sets error highlights in the cuirrent window
function! g:SyntasticHighlightingNotifier.refresh(loclist)
function! g:SyntasticHighlightingNotifier.refresh(loclist) " {{{2
if self.enabled()
call self.reset(a:loclist)
call syntastic#log#debug(g:SyntasticDebugNotifications, 'highlighting: refresh')
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 = item['type'] ==? 'E' ? 'SyntasticError' : 'SyntasticWarning'
let group = 'Syntastic' . get(item, 'subtype', '') . ( item['type'] ==? 'E' ? 'Error' : 'Warning' )
" The function `Syntastic_{filetype}_{checker}_GetHighlightRegex` is
" used to override default highlighting.
@ -59,35 +57,48 @@ function! g:SyntasticHighlightingNotifier.refresh(loclist)
endif
endfor
endif
endfunction
endfunction " }}}2
" Remove all error highlights from the window
" @vimlint(EVL103, 1, a:loclist)
function! g:SyntasticHighlightingNotifier.reset(loclist)
function! g:SyntasticHighlightingNotifier.reset(loclist) " {{{2
if s:has_highlighting
call syntastic#log#debug(g:SyntasticDebugNotifications, 'highlighting: reset')
for match in getmatches()
if stridx(match['group'], 'Syntastic') == 0
call matchdelete(match['id'])
endif
endfor
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'highlighting: reset')
call self._reset()
endif
endfunction
endfunction " }}}2
" @vimlint(EVL103, 0, a:loclist)
" }}}1
" Private methods {{{1
" One time setup: define our own highlighting
function! g:SyntasticHighlightingNotifier._setup()
function! g:SyntasticHighlightingNotifier._setup() " {{{2
if s:has_highlighting
if !hlexists('SyntasticError')
highlight link SyntasticError SpellBad
endif
if !hlexists('SyntasticWarning')
highlight link SyntasticWarning SpellCap
endif
if !hlexists('SyntasticStyleError')
highlight link SyntasticStyleError SyntasticError
endif
if !hlexists('SyntasticStyleWarning')
highlight link SyntasticStyleWarning SyntasticWarning
endif
endif
endfunction
endfunction " }}}2
function! g:SyntasticHighlightingNotifier._reset() " {{{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:

@ -1,4 +1,4 @@
if exists("g:loaded_syntastic_loclist")
if exists("g:loaded_syntastic_loclist") || !exists("g:loaded_syntastic_plugin")
finish
endif
let g:loaded_syntastic_loclist = 1
@ -7,7 +7,7 @@ let g:SyntasticLoclist = {}
" Public methods {{{1
function! g:SyntasticLoclist.New(rawLoclist)
function! g:SyntasticLoclist.New(rawLoclist) " {{{2
let newObj = copy(self)
let llist = filter(copy(a:rawLoclist), 'v:val["valid"] == 1')
@ -20,36 +20,67 @@ function! g:SyntasticLoclist.New(rawLoclist)
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
endfunction " }}}2
function! g:SyntasticLoclist.current()
if !exists("b:syntastic_loclist")
function! g:SyntasticLoclist.current() " {{{2
if !exists("b:syntastic_loclist") || empty(b:syntastic_loclist)
let b:syntastic_loclist = g:SyntasticLoclist.New([])
endif
return b:syntastic_loclist
endfunction
endfunction " }}}2
function! g:SyntasticLoclist.extend(other)
function! g:SyntasticLoclist.extend(other) " {{{2
let list = self.copyRaw()
call extend(list, a:other.copyRaw())
return g:SyntasticLoclist.New(list)
endfunction
endfunction " }}}2
function! g:SyntasticLoclist.isEmpty()
function! g:SyntasticLoclist.sort() " {{{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() " {{{2
return empty(self._rawLoclist)
endfunction
endfunction " }}}2
function! g:SyntasticLoclist.copyRaw()
function! g:SyntasticLoclist.isNewerThan(stamp) " {{{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() " {{{2
return copy(self._rawLoclist)
endfunction
endfunction " }}}2
function! g:SyntasticLoclist.getRaw()
function! g:SyntasticLoclist.getRaw() " {{{2
return self._rawLoclist
endfunction
endfunction " }}}2
function! g:SyntasticLoclist.getBuffers() " {{{2
return syntastic#util#unique(map(copy(self._rawLoclist), 'str2nr(v:val["bufnr"])') + [self._owner])
endfunction " }}}2
function! g:SyntasticLoclist.getCursorColumns() " {{{2
return self._columns
endfunction " }}}2
function! g:SyntasticLoclist.getStatuslineFlag()
function! g:SyntasticLoclist.getStatuslineFlag() " {{{2
if !exists("self._stl_format")
let self._stl_format = ''
endif
@ -100,56 +131,108 @@ function! g:SyntasticLoclist.getStatuslineFlag()
endif
return self._stl_flag
endfunction
endfunction " }}}2
function! g:SyntasticLoclist.getFirstError(...) " {{{2
let max_issues = len(self._rawLoclist)
if a:0 && a:1 < max_issues
let max_issues = a:1
endif
function! g:SyntasticLoclist.getFirstIssue()
return get(self._rawLoclist, 0, {})
endfunction
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()
function! g:SyntasticLoclist.getName() " {{{2
return len(self._name)
endfunction
endfunction " }}}2
function! g:SyntasticLoclist.setName(name)
function! g:SyntasticLoclist.setName(name) " {{{2
let self._name = a:name
endfunction
endfunction " }}}2
function! g:SyntasticLoclist.decorate(name, filetype)
function! g:SyntasticLoclist.getOwner() " {{{2
return self._owner
endfunction " }}}2
function! g:SyntasticLoclist.setOwner(buffer) " {{{2
let self._owner = type(a:buffer) == type(0) ? a:buffer : str2nr(a:buffer)
endfunction " }}}2
function! g:SyntasticLoclist.deploy() " {{{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() " {{{2
for buf in self.getBuffers()
call setbufvar(buf, 'syntastic_loclist', {})
endfor
endfunction " }}}2
function! g:SyntasticLoclist.decorate(tag) " {{{2
for e in self._rawLoclist
let e['text'] .= ' [' . a:filetype . '/' . a:name . ']'
let e['text'] .= ' [' . a:tag . ']'
endfor
endfunction
endfunction " }}}2
function! g:SyntasticLoclist.balloons() " {{{2
if !exists("self._cachedBalloons")
let sep = has("balloon_multiline") ? "\n" : ' | '
let self._cachedBalloons = {}
for e in self._rawLoclist
let buf = e['bufnr']
function! g:SyntasticLoclist.quietMessages(filters)
call syntastic#util#dictFilter(self._rawLoclist, a:filters)
endfunction
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()
function! g:SyntasticLoclist.errors() " {{{2
if !exists("self._cachedErrors")
let self._cachedErrors = self.filter({'type': "E"})
endif
return self._cachedErrors
endfunction
endfunction " }}}2
function! g:SyntasticLoclist.warnings()
function! g:SyntasticLoclist.warnings() " {{{2
if !exists("self._cachedWarnings")
let self._cachedWarnings = self.filter({'type': "W"})
endif
return self._cachedWarnings
endfunction
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()
function! g:SyntasticLoclist.hasErrorsOrWarningsToDisplay() " {{{2
return !self.isEmpty()
endfunction
endfunction " }}}2
" cache used by EchoCurrentError()
function! g:SyntasticLoclist.messages(buf)
function! g:SyntasticLoclist.messages(buf) " {{{2
if !exists("self._cachedMessages")
let self._cachedMessages = {}
let errors = self.errors() + self.warnings()
let errors = self.errors() + self.warnings()
for e in errors
let b = e['bufnr']
let l = e['lnum']
@ -159,13 +242,36 @@ function! g:SyntasticLoclist.messages(buf)
endif
if !has_key(self._cachedMessages[b], l)
let self._cachedMessages[b][l] = e['text']
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
endfunction " }}}2
"Filter the list and return new native loclist
"e.g.
@ -174,31 +280,31 @@ endfunction
"would return all errors for buffer 10.
"
"Note that all comparisons are done with ==?
function! g:SyntasticLoclist.filter(filters)
let conditions = values(map(copy(a:filters), 's:translate(v:key, v:val)'))
function! g:SyntasticLoclist.filter(filters) " {{{2
let conditions = values(map(copy(a:filters), 's:_translate(v:key, v:val)'))
let filter = len(conditions) == 1 ?
\ conditions[0] : join(map(conditions, '"(" . v:val . ")"'), ' && ')
return filter(copy(self._rawLoclist), filter)
endfunction
endfunction " }}}2
function! g:SyntasticLoclist.setloclist()
function! g:SyntasticLoclist.setloclist() " {{{2
if !exists('w:syntastic_loclist_set')
let w:syntastic_loclist_set = 0
endif
let replace = g:syntastic_reuse_loc_lists && w:syntastic_loclist_set
call syntastic#log#debug(g:SyntasticDebugNotifications, 'loclist: setloclist ' . (replace ? '(replace)' : '(new)'))
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'loclist: setloclist ' . (replace ? '(replace)' : '(new)'))
call setloclist(0, self.getRaw(), replace ? 'r' : ' ')
let w:syntastic_loclist_set = 1
endfunction
endfunction " }}}2
"display the cached errors for this buf in the location list
function! g:SyntasticLoclist.show()
call syntastic#log#debug(g:SyntasticDebugNotifications, 'loclist: show')
function! g:SyntasticLoclist.show() " {{{2
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'loclist: show')
call self.setloclist()
if !self.isEmpty()
let num = winnr()
execute "lopen " . g:syntastic_loc_list_height
execute "lopen " . syntastic#util#var('loc_list_height')
if num != winnr()
wincmd p
endif
@ -216,23 +322,113 @@ function! g:SyntasticLoclist.show()
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
endfunction " }}}2
" }}}1
" Non-method functions {{{1
" Public functions {{{1
function! g:SyntasticLoclistHide()
call syntastic#log#debug(g:SyntasticDebugNotifications, 'loclist: hide')
function! SyntasticLoclistHide() " {{{2
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'loclist: hide')
silent! lclose
endfunction
endfunction " }}}2
" }}}1
" Private functions {{{1
" Utilities {{{1
function! s:translate(key, val)
function! s:_translate(key, val) " {{{2
return 'get(v:val, ' . string(a:key) . ', "") ==? ' . string(a:val)
endfunction
endfunction " }}}2
function! s:_set_screen_column(item) " {{{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) " {{{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) " {{{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) " {{{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:

@ -1,4 +1,4 @@
if exists("g:loaded_syntastic_modemap")
if exists("g:loaded_syntastic_modemap") || !exists("g:loaded_syntastic_plugin")
finish
endif
let g:loaded_syntastic_modemap = 1
@ -7,28 +7,28 @@ let g:SyntasticModeMap = {}
" Public methods {{{1
function! g:SyntasticModeMap.Instance()
function! g:SyntasticModeMap.Instance() " {{{2
if !exists('s:SyntasticModeMapInstance')
let s:SyntasticModeMapInstance = copy(self)
call s:SyntasticModeMapInstance.synch()
endif
return s:SyntasticModeMapInstance
endfunction
endfunction " }}}2
function! g:SyntasticModeMap.synch()
function! g:SyntasticModeMap.synch() " {{{2
if exists('g:syntastic_mode_map')
let self._mode = get(g:syntastic_mode_map, 'mode', 'active')
let self._activeFiletypes = get(g:syntastic_mode_map, 'active_filetypes', [])
let self._passiveFiletypes = get(g:syntastic_mode_map, 'passive_filetypes', [])
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
endfunction " }}}2
function! g:SyntasticModeMap.allowsAutoChecking(filetype)
function! g:SyntasticModeMap.allowsAutoChecking(filetype) " {{{2
let fts = split(a:filetype, '\m\.')
if self.isPassive()
@ -36,13 +36,22 @@ function! g:SyntasticModeMap.allowsAutoChecking(filetype)
else
return self._noFiletypesArePassive(fts)
endif
endfunction
endfunction " }}}2
function! g:SyntasticModeMap.isPassive()
function! g:SyntasticModeMap.doAutoChecking() " {{{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() " {{{2
return self._mode ==# 'passive'
endfunction
endfunction " }}}2
function! g:SyntasticModeMap.toggleMode()
function! g:SyntasticModeMap.toggleMode() " {{{2
call self.synch()
if self._mode ==# 'active'
@ -56,20 +65,53 @@ function! g:SyntasticModeMap.toggleMode()
let g:syntastic_mode_map = {}
endif
let g:syntastic_mode_map['mode'] = self._mode
endfunction
endfunction " }}}2
function! g:SyntasticModeMap.echoMode()
function! g:SyntasticModeMap.echoMode() " {{{2
echo "Syntastic: " . self._mode . " mode enabled"
endfunction
endfunction " }}}2
function! g:SyntasticModeMap.modeInfo(filetypes) " {{{2
echomsg 'Syntastic version: ' . g:_SYNTASTIC_VERSION
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)
function! g:SyntasticModeMap._isOneFiletypeActive(filetypes) " {{{2
return !empty(filter(copy(a:filetypes), 'index(self._activeFiletypes, v:val) != -1'))
endfunction
endfunction " }}}2
function! g:SyntasticModeMap._noFiletypesArePassive(filetypes)
function! g:SyntasticModeMap._noFiletypesArePassive(filetypes) " {{{2
return empty(filter(copy(a:filetypes), 'index(self._passiveFiletypes, v:val) != -1'))
endfunction
endfunction " }}}2
" }}}1
" vim: set sw=4 sts=4 et fdm=marker:

@ -1,35 +1,55 @@
if exists("g:loaded_syntastic_notifiers")
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']
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()
function! g:SyntasticNotifiers.Instance() " {{{2
if !exists('s:SyntasticNotifiersInstance')
let s:SyntasticNotifiersInstance = copy(self)
call s:SyntasticNotifiersInstance._initNotifiers()
endif
return s:SyntasticNotifiersInstance
endfunction
endfunction " }}}2
function! g:SyntasticNotifiers.refresh(loclist) " {{{2
if !a:loclist.isEmpty() && !a:loclist.isNewerThan([])
" loclist not fully constructed yet
return
endif
function! g:SyntasticNotifiers.refresh(loclist)
call syntastic#log#debug(g:SyntasticDebugNotifications, 'notifiers: refresh')
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()
call self._notifier[type].refresh(a:loclist)
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
endfunction " }}}2
function! g:SyntasticNotifiers.reset(loclist)
call syntastic#log#debug(g:SyntasticDebugNotifications, 'notifiers: reset')
function! g:SyntasticNotifiers.reset(loclist) " {{{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', '')
@ -39,19 +59,28 @@ function! g:SyntasticNotifiers.reset(loclist)
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
endfunction " }}}2
" }}}1
" Private methods {{{1
function! g:SyntasticNotifiers._initNotifiers()
function! g:SyntasticNotifiers._initNotifiers() " {{{2
let self._notifier = {}
for type in s:notifier_types
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
let self._enabled_types = copy(s:_NOTIFIER_TYPES)
endfunction " }}}2
" }}}1
" vim: set sw=4 sts=4 et fdm=marker:

@ -1,16 +1,20 @@
if exists("g:loaded_syntastic_registry")
if exists("g:loaded_syntastic_registry") || !exists("g:loaded_syntastic_plugin")
finish
endif
let g:loaded_syntastic_registry = 1
let s:defaultCheckers = {
" Initialisation {{{1
let s:_DEFAULT_CHECKERS = {
\ 'actionscript':['mxmlc'],
\ 'ada': ['gcc'],
\ 'applescript': ['osacompile'],
\ 'asciidoc': ['asciidoc'],
\ 'asm': ['gcc'],
\ 'bro': ['bro'],
\ 'bemhtml': ['bemhtmllint'],
\ 'c': ['gcc'],
\ 'cabal': ['cabal'],
\ 'chef': ['foodcritic'],
\ 'co': ['coco'],
\ 'cobol': ['cobc'],
@ -18,14 +22,14 @@ let s:defaultCheckers = {
\ 'coq': ['coqtop'],
\ 'cpp': ['gcc'],
\ 'cs': ['mcs'],
\ 'css': ['csslint', 'phpcs'],
\ 'css': ['csslint'],
\ 'cucumber': ['cucumber'],
\ 'cuda': ['nvcc'],
\ 'd': ['dmd'],
\ 'dart': ['dartanalyzer'],
\ 'docbk': ['xmllint'],
\ 'dustjs': ['swiffer'],
\ 'elixir': ['elixir'],
\ 'elixir': [],
\ 'erlang': ['escript'],
\ 'eruby': ['ruby'],
\ 'fortran': ['gfortran'],
@ -46,31 +50,34 @@ let s:defaultCheckers = {
\ 'lisp': ['clisp'],
\ 'llvm': ['llvm'],
\ 'lua': ['luac'],
\ 'markdown': ['mdl'],
\ 'matlab': ['mlint'],
\ 'nasm': ['nasm'],
\ 'nroff': ['mandoc'],
\ 'objc': ['gcc'],
\ 'objcpp': ['gcc'],
\ 'ocaml': ['camlp4o'],
\ 'perl': ['perl', 'perlcritic'],
\ 'perl': ['perlcritic'],
\ 'php': ['php', 'phpcs', 'phpmd'],
\ 'po': ['msgfmt'],
\ 'pod': ['podchecker'],
\ 'puppet': ['puppet', 'puppetlint'],
\ 'python': ['python', 'flake8', 'pylint'],
\ 'r': [],
\ 'racket': ['racket'],
\ 'rnc': ['rnv'],
\ 'rst': ['rst2pseudoxml'],
\ 'ruby': ['mri'],
\ 'rust': ['rustc'],
\ 'sass': ['sass'],
\ 'scala': ['fsc', 'scalac'],
\ 'scss': ['sass', 'scss_lint'],
\ 'sh': ['sh', 'shellcheck'],
\ 'slim': ['slimrb'],
\ 'spec': ['rpmlint'],
\ 'tcl': ['nagelfar'],
\ 'tex': ['lacheck', 'chktex'],
\ 'texinfo': ['makeinfo'],
\ 'text': ['atdtool'],
\ 'text': [],
\ 'twig': ['twiglint'],
\ 'typescript': ['tsc'],
\ 'vala': ['valac'],
@ -84,199 +91,239 @@ let s:defaultCheckers = {
\ 'yaml': ['jsyaml'],
\ 'z80': ['z80syntaxchecker'],
\ 'zpt': ['zptlint'],
\ 'zsh': ['zsh', 'shellcheck']
\ 'zsh': ['zsh', 'shellcheck'],
\ }
lockvar! s:_DEFAULT_CHECKERS
let s:defaultFiletypeMap = {
let s:_DEFAULT_FILETYPE_MAP = {
\ 'gentoo-metadata': 'xml',
\ 'groff': 'nroff',
\ 'lhaskell': 'haskell',
\ 'litcoffee': 'coffee'
\ 'litcoffee': 'coffee',
\ 'mail': 'text',
\ 'mkd': 'markdown',
\ '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 = {}
" TODO: Handling of filetype aliases: all public methods take aliases as
" parameters, all private methods take normalized filetypes. Public methods
" are thus supposed to normalize filetypes before calling private methods.
" }}}1
" Public methods {{{1
function! g:SyntasticRegistry.Instance()
" 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() " {{{2
if !exists('s:SyntasticRegistryInstance')
let s:SyntasticRegistryInstance = copy(self)
let s:SyntasticRegistryInstance._checkerMap = {}
let s:SyntasticRegistryInstance._cachedCheckersFor = {}
endif
return s:SyntasticRegistryInstance
endfunction
endfunction " }}}2
function! g:SyntasticRegistry.CreateAndRegisterChecker(args)
function! g:SyntasticRegistry.CreateAndRegisterChecker(args) " {{{2
let checker = g:SyntasticChecker.New(a:args)
let registry = g:SyntasticRegistry.Instance()
call registry._registerChecker(checker)
endfunction
function! g:SyntasticRegistry.checkable(ftalias)
return !empty(self.getActiveCheckers(a:ftalias))
endfunction
function! g:SyntasticRegistry.getActiveCheckers(ftalias)
let filetype = s:SyntasticRegistryNormaliseFiletype(a:ftalias)
let checkers = self.availableCheckersFor(a:ftalias)
if self._userHasFiletypeSettings(filetype)
return self._filterCheckersByUserSettings(checkers, filetype)
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) " {{{2
let ft = s:_normalise_filetype(a:ftalias)
call self._loadCheckersFor(ft)
let checkers_map = self._checkerMap[ft]
if empty(checkers_map)
return []
endif
if has_key(s:defaultCheckers, filetype)
return self._filterCheckersByDefaultSettings(checkers, filetype)
endif
call self._checkDeprecation(ft)
return checkers[0:0]
endfunction
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)
function! g:SyntasticRegistry.getCheckers(ftalias, list)
return self._filterCheckersByName(self.availableCheckersFor(a:ftalias), a:list)
endfunction
return type(names) == type([]) ?
\ self._filterCheckersByName(checkers_map, names) : [checkers_map[keys(checkers_map)[0]]]
endfunction " }}}2
function! g:SyntasticRegistry.availableCheckersFor(ftalias)
if !has_key(self._cachedCheckersFor, a:ftalias)
let filetype = s:SyntasticRegistryNormaliseFiletype(a:ftalias)
let checkers = self._allCheckersFor(filetype)
let self._cachedCheckersFor[a:ftalias] = self._filterCheckersByAvailability(checkers)
endif
" Same as getCheckers(), but keep only the checkers available. This runs the
" corresponding IsAvailable() functions for all checkers.
function! g:SyntasticRegistry.getCheckersAvailable(ftalias, hints_list) " {{{2
return filter(self.getCheckers(a:ftalias, a:hints_list), 'v:val.isAvailable()')
endfunction " }}}2
function! g:SyntasticRegistry.getKnownFiletypes() " {{{2
let types = keys(s:_DEFAULT_CHECKERS)
return self._cachedCheckersFor[a:ftalias]
endfunction
call extend(types, keys(s:_DEFAULT_FILETYPE_MAP))
function! g:SyntasticRegistry.knownFiletypes()
let types = keys(s:defaultCheckers)
call extend(types, keys(s:defaultFiletypeMap))
if exists('g:syntastic_filetype_map')
call extend(types, keys(g:syntastic_filetype_map))
endif
if exists('g:syntastic_extra_filetypes') && type(g:syntastic_extra_filetypes) == type([])
call extend(types, g:syntastic_extra_filetypes)
endif
return syntastic#util#unique(types)
endfunction
function! g:SyntasticRegistry.echoInfoFor(ftalias_list)
echomsg "Syntastic info for filetype: " . join(a:ftalias_list, '.')
return syntastic#util#unique(types)
endfunction " }}}2
function! g:SyntasticRegistry.getNamesOfAvailableCheckers(ftalias) " {{{2
let ft = s:_normalise_filetype(a:ftalias)
call self._loadCheckersFor(ft)
return keys(filter( copy(self._checkerMap[ft]), 'v:val.isAvailable()' ))
endfunction " }}}2
function! g:SyntasticRegistry.echoInfoFor(ftalias_list) " {{{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 = []
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()' ))
endfor
else
let ft = ft_list[0]
let available = self.getNamesOfAvailableCheckers(ft)
let active = map(self.getCheckersAvailable(ft, []), 'v:val.getName()')
endif
let available = []
let active = []
for ftalias in a:ftalias_list
call extend(available, self.availableCheckersFor(ftalias))
call extend(active, self.getActiveCheckers(ftalias))
endfor
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
" 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
echomsg "Available checker(s): " . join(syntastic#util#unique(map(available, "v:val.getName()")))
echomsg "Currently enabled checker(s): " . join(syntastic#util#unique(map(active, "v:val.getName()")))
endfunction
" }}}1
" Private methods {{{1
function! g:SyntasticRegistry._registerChecker(checker) abort
function! g:SyntasticRegistry._registerChecker(checker) abort " {{{2
let ft = a:checker.getFiletype()
if !has_key(self._checkerMap, ft)
let self._checkerMap[ft] = []
endif
call self._validateUniqueName(a:checker)
call add(self._checkerMap[ft], a:checker)
endfunction
function! g:SyntasticRegistry._allCheckersFor(filetype)
call self._loadCheckers(a:filetype)
if empty(self._checkerMap[a:filetype])
return []
endif
return self._checkerMap[a:filetype]
endfunction
function! g:SyntasticRegistry._filterCheckersByDefaultSettings(checkers, filetype)
if has_key(s:defaultCheckers, a:filetype)
return self._filterCheckersByName(a:checkers, s:defaultCheckers[a:filetype])
let self._checkerMap[ft] = {}
endif
return a:checkers
endfunction
function! g:SyntasticRegistry._filterCheckersByUserSettings(checkers, filetype)
if exists("b:syntastic_checkers")
let whitelist = b:syntastic_checkers
else
let whitelist = g:syntastic_{a:filetype}_checkers
let name = a:checker.getName()
if has_key(self._checkerMap[ft], name)
throw 'Syntastic: Duplicate syntax checker name: ' . ft . '/' . name
endif
return self._filterCheckersByName(a:checkers, whitelist)
endfunction
function! g:SyntasticRegistry._filterCheckersByName(checkers, list)
let checkers_by_name = {}
for c in a:checkers
let checkers_by_name[c.getName()] = c
endfor
let filtered = []
for name in a:list
if has_key(checkers_by_name, name)
call add(filtered, checkers_by_name[name])
endif
endfor
return filtered
endfunction
let self._checkerMap[ft][name] = a:checker
endfunction " }}}2
function! g:SyntasticRegistry._filterCheckersByAvailability(checkers)
return filter(copy(a:checkers), "v:val.isAvailable()")
endfunction
function! g:SyntasticRegistry._filterCheckersByName(checkers_map, list) " {{{2
return filter( map(copy(a:list), 'get(a:checkers_map, v:val, {})'), '!empty(v:val)' )
endfunction " }}}2
function! g:SyntasticRegistry._loadCheckers(filetype)
if self._haveLoadedCheckers(a:filetype)
function! g:SyntasticRegistry._loadCheckersFor(filetype) " {{{2
if 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] = []
let self._checkerMap[a:filetype] = {}
endif
endfunction
endfunction " }}}2
function! g:SyntasticRegistry._haveLoadedCheckers(filetype)
return has_key(self._checkerMap, a:filetype)
endfunction
function! g:SyntasticRegistry._userHasFiletypeSettings(filetype)
if exists("g:syntastic_" . a:filetype . "_checker") && !exists("g:syntastic_" . a:filetype . "_checkers")
" Check for obsolete variable g:syntastic_<filetype>_checker
function! g:SyntasticRegistry._checkDeprecation(filetype) " {{{2
if exists('g:syntastic_' . a:filetype . '_checker') && !exists('g:syntastic_' . a:filetype . '_checkers')
let g:syntastic_{a:filetype}_checkers = [g:syntastic_{a:filetype}_checker]
call syntastic#log#deprecationWarn("variable g:syntastic_" . a:filetype . "_checker is deprecated")
call syntastic#log#oneTimeWarn('variable g:syntastic_' . a:filetype . '_checker is deprecated')
endif
return exists("b:syntastic_checkers") || exists("g:syntastic_" . a:filetype . "_checkers")
endfunction
endfunction " }}}2
function! g:SyntasticRegistry._validateUniqueName(checker) abort
for checker in self._allCheckersFor(a:checker.getFiletype())
if checker.getName() ==# a:checker.getName()
throw "Syntastic: Duplicate syntax checker name for: " . a:checker.getName()
endif
endfor
endfunction
" }}}1
" Private functions {{{1
" Utilities {{{1
"resolve filetype aliases, and replace - with _ otherwise we cant name
"syntax checker functions legally for filetypes like "gentoo-metadata"
function! s:SyntasticRegistryNormaliseFiletype(ftalias)
let ft = get(s:defaultFiletypeMap, a:ftalias, a:ftalias)
function! s:_normalise_filetype(ftalias) " {{{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
endfunction " }}}2
function! s:_disabled_by_eclim(filetype) " {{{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) " {{{2
return index(s:_YCM_TYPES, a:filetype) >= 0
endfunction " }}}2
" }}}1
" vim: set sw=4 sts=4 et fdm=marker:

@ -1,28 +1,9 @@
if exists("g:loaded_syntastic_notifier_signs")
if exists("g:loaded_syntastic_notifier_signs") || !exists("g:loaded_syntastic_plugin")
finish
endif
let g:loaded_syntastic_notifier_signs = 1
if !exists("g:syntastic_enable_signs")
let g:syntastic_enable_signs = 1
endif
if !exists("g:syntastic_error_symbol")
let g:syntastic_error_symbol = '>>'
endif
if !exists("g:syntastic_warning_symbol")
let g:syntastic_warning_symbol = '>>'
endif
if !exists("g:syntastic_style_error_symbol")
let g:syntastic_style_error_symbol = 'S>'
endif
if !exists("g:syntastic_style_warning_symbol")
let g:syntastic_style_warning_symbol = 'S>'
endif
" 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
@ -34,37 +15,41 @@ let g:SyntasticSignsNotifier = {}
let s:setup_done = 0
" }}}1
" Public methods {{{1
function! g:SyntasticSignsNotifier.New()
function! g:SyntasticSignsNotifier.New() " {{{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
endfunction " }}}2
function! g:SyntasticSignsNotifier.enabled()
function! g:SyntasticSignsNotifier.enabled() " {{{2
return has('signs') && syntastic#util#var('enable_signs')
endfunction
endfunction " }}}2
function! g:SyntasticSignsNotifier.refresh(loclist)
call syntastic#log#debug(g:SyntasticDebugNotifications, 'signs: refresh')
function! g:SyntasticSignsNotifier.refresh(loclist) " {{{2
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'signs: refresh')
let old_signs = copy(self._bufSignIds())
if self.enabled()
call self._signErrors(a:loclist)
endif
call self._removeSigns(old_signs)
let s:first_sign_id = s:next_sign_id
endfunction
endfunction " }}}2
" }}}1
" Private methods {{{1
" One time setup: define our own sign types and highlighting
function! g:SyntasticSignsNotifier._setup()
function! g:SyntasticSignsNotifier._setup() " {{{2
if has('signs')
if !hlexists('SyntasticErrorSign')
highlight link SyntasticErrorSign error
@ -86,31 +71,36 @@ function! g:SyntasticSignsNotifier._setup()
endif
" define the signs used to display syntax and style errors/warns
exe 'sign define SyntasticError text=' . g:syntastic_error_symbol .
execute 'sign define SyntasticError text=' . g:syntastic_error_symbol .
\ ' texthl=SyntasticErrorSign linehl=SyntasticErrorLine'
exe 'sign define SyntasticWarning text=' . g:syntastic_warning_symbol .
execute 'sign define SyntasticWarning text=' . g:syntastic_warning_symbol .
\ ' texthl=SyntasticWarningSign linehl=SyntasticWarningLine'
exe 'sign define SyntasticStyleError text=' . g:syntastic_style_error_symbol .
execute 'sign define SyntasticStyleError text=' . g:syntastic_style_error_symbol .
\ ' texthl=SyntasticStyleErrorSign linehl=SyntasticStyleErrorLine'
exe 'sign define SyntasticStyleWarning text=' . g:syntastic_style_warning_symbol .
execute 'sign define SyntasticStyleWarning text=' . g:syntastic_style_warning_symbol .
\ ' texthl=SyntasticStyleWarningSign linehl=SyntasticStyleWarningLine'
endif
endfunction
endfunction " }}}2
" Place signs by all syntax errors in the buffer
function! g:SyntasticSignsNotifier._signErrors(loclist)
function! g:SyntasticSignsNotifier._signErrors(loclist) " {{{2
let loclist = a:loclist
if !loclist.isEmpty()
" errors some first, so that they are not masked by warnings
let buf = bufnr('')
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 !has_key(seen, i['lnum'])
if i['lnum'] > 0 && !has_key(seen, i['lnum'])
let seen[i['lnum']] = 1
let sign_severity = i['type'] ==? 'W' ? 'Warning' : 'Error'
@ -123,24 +113,26 @@ function! g:SyntasticSignsNotifier._signErrors(loclist)
endif
endfor
endif
endfunction
endfunction " }}}2
" Remove the signs with the given ids from this buffer
function! g:SyntasticSignsNotifier._removeSigns(ids)
function! g:SyntasticSignsNotifier._removeSigns(ids) " {{{2
if has('signs')
for i in a:ids
execute "sign unplace " . i
call remove(self._bufSignIds(), index(self._bufSignIds(), i))
for s in reverse(copy(a:ids))
execute "sign unplace " . s
call remove(self._bufSignIds(), index(self._bufSignIds(), s))
endfor
endif
endfunction
endfunction " }}}2
" Get all the ids of the SyntaxError signs in the buffer
function! g:SyntasticSignsNotifier._bufSignIds()
if !exists("b:syntastic_sign_ids")
let b:syntastic_sign_ids = []
function! g:SyntasticSignsNotifier._bufSignIds() " {{{2
if !exists("b:syntastic_private_sign_ids")
let b:syntastic_private_sign_ids = []
endif
return b:syntastic_sign_ids
endfunction
return b:syntastic_private_sign_ids
endfunction " }}}2
" }}}1
" vim: set sw=4 sts=4 et fdm=marker:

@ -14,10 +14,6 @@ if exists('g:loaded_syntastic_actionscript_mxmlc_checker')
endif
let g:loaded_syntastic_actionscript_mxmlc_checker = 1
if !exists('g:syntastic_actionscript_mxmlc_conf')
let g:syntastic_actionscript_mxmlc_conf = ''
endif
let s:save_cpo = &cpo
set cpo&vim
@ -41,14 +37,14 @@ function! SyntaxCheckers_actionscript_mxmlc_GetHighlightRegex(item)
endif
return term != '' ? '\V\<' . term . '\>' : ''
return term != '' ? '\V\<' . escape(term, '\') . '\>' : ''
endfunction
function! SyntaxCheckers_actionscript_mxmlc_GetLocList() dict
let makeprg = self.makeprgBuild({
\ 'args_before': (g:syntastic_actionscript_mxmlc_conf != '' ?
\ ' -load-config+=' . g:syntastic_actionscript_mxmlc_conf : ''),
\ 'args_after': '-output=' . syntastic#util#DevNull() })
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,' .
@ -68,4 +64,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -23,7 +23,7 @@ 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))
return executable(expand(g:syntastic_ada_compiler, 1))
endfunction
function! SyntaxCheckers_ada_gcc_GetLocList() dict
@ -44,4 +44,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -46,4 +46,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -44,4 +44,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -22,14 +22,14 @@ endif
let s:save_cpo = &cpo
set cpo&vim
function! SyntaxCheckers_asm_gcc_IsAvailable() dict
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))
endfunction
return executable(expand(g:syntastic_asm_compiler, 1))
endfunction " }}}1
function! SyntaxCheckers_asm_gcc_GetLocList() dict
function! SyntaxCheckers_asm_gcc_GetLocList() dict " {{{1
return syntastic#c#GetLocList('asm', 'gcc', {
\ 'errorformat':
\ '%-G%f:%s:,' .
@ -37,12 +37,16 @@ function! SyntaxCheckers_asm_gcc_GetLocList() dict
\ '%f:%l:%c: %tarning: %m,' .
\ '%f:%l: %m',
\ 'main_flags': '-x assembler -fsyntax-only -masm=' . s:GetDialect() })
endfunction
endfunction " }}}1
function! s:GetDialect()
" Utilities {{{1
function! s:GetDialect() " {{{2
return exists('g:syntastic_asm_dialect') ? g:syntastic_asm_dialect :
\ expand('%:e') ==? 'asm' ? 'intel' : 'att'
endfunction
\ expand('%:e', 1) ==? 'asm' ? 'intel' : 'att'
endfunction " }}}2
" }}}1
call g:SyntasticRegistry.CreateAndRegisterChecker({
\ 'filetype': 'asm',
@ -51,4 +55,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -8,7 +8,7 @@
" Want To 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
@ -29,6 +29,7 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
\ 'name': 'bemhtmllint',
\ 'exec': 'bemhtml-lint' })
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set sw=4 sts=4 et fdm=marker:

@ -0,0 +1,60 @@
"============================================================================
"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 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 =
\ 'fatal %trror in %f\, line %l: %m,' .
\ '%trror in %f\, line %l: %m,' .
\ '%tarning in %f\, line %l: %m'
return SyntasticMake({
\ 'makeprg': makeprg,
\ 'errorformat': errorformat })
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:

@ -53,3 +53,5 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set sw=4 sts=4 et fdm=marker:

@ -14,24 +14,29 @@ if exists("g:loaded_syntastic_c_checkpatch_checker")
endif
let g:loaded_syntastic_c_checkpatch_checker = 1
" Bail if the user doesn't have `checkpatch.pl` or ./scripts/checkpatch.pl installed.
if executable("checkpatch.pl")
let g:syntastic_c_checker_checkpatch_location = 'checkpatch.pl'
elseif executable("./scripts/checkpatch.pl")
let g:syntastic_c_checker_checkpatch_location = './scripts/checkpatch.pl'
endif
let s:save_cpo = &cpo
set cpo&vim
function! SyntaxCheckers_c_checkpatch_IsAvailable() dict
return exists("g:syntastic_c_checker_checkpatch_location")
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({
\ 'exe': g:syntastic_c_checker_checkpatch_location,
\ 'args_after': '--no-summary --no-tree --terse --file' })
let makeprg = self.makeprgBuild({ 'args_after': '--no-summary --no-tree --terse --file' })
let errorformat =
\ '%f:%l: %tARNING: %m,' .
@ -52,4 +57,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -0,0 +1,61 @@
"============================================================================
"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'
return SyntasticMake({
\ 'makeprg': makeprg,
\ 'errorformat': errorformat,
\ '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:

@ -0,0 +1,61 @@
"============================================================================
"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'
return SyntasticMake({
\ 'makeprg': makeprg,
\ 'errorformat': errorformat,
\ '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:

@ -8,13 +8,6 @@
" Want To Public License, Version 2, as published by Sam Hocevar.
" See http://sam.zoy.org/wtfpl/COPYING for more details.
"============================================================================
"
" The setting 'g:syntastic_cppcheck_config_file' allows you to define a file
" that contains additional compiler arguments like include directories or
" CFLAGS. The file is expected to contain one option per line. If none is
" given the filename defaults to '.syntastic_cppcheck_config':
"
" let g:syntastic_cppcheck_config_file = '.config'
if exists("g:loaded_syntastic_c_cppcheck_checker")
finish
@ -28,10 +21,6 @@ endif
let s:save_cpo = &cpo
set cpo&vim
function! SyntaxCheckers_c_cppcheck_Preprocess(errors)
return map(copy(a:errors), 'substitute(v:val, ''\v^\[[^]]+\]\zs( -\> \[[^]]+\])+\ze:'', "", "")')
endfunction
function! SyntaxCheckers_c_cppcheck_GetLocList() dict
let makeprg = self.makeprgBuild({
\ 'args': syntastic#c#ReadConfig(g:syntastic_cppcheck_config_file),
@ -50,7 +39,7 @@ function! SyntaxCheckers_c_cppcheck_GetLocList() dict
let loclist = SyntasticMake({
\ 'makeprg': makeprg,
\ 'errorformat': errorformat,
\ 'preprocess': 'SyntaxCheckers_c_cppcheck_Preprocess',
\ 'preprocess': 'cppcheck',
\ 'returns': [0] })
for e in loclist
@ -70,4 +59,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -26,7 +26,8 @@ function! SyntaxCheckers_c_gcc_IsAvailable() dict
if !exists('g:syntastic_c_compiler')
let g:syntastic_c_compiler = executable(self.getExec()) ? self.getExec() : 'clang'
endif
return executable(expand(g:syntastic_c_compiler))
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
@ -55,4 +56,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -19,7 +19,7 @@ let s:save_cpo = &cpo
set cpo&vim
function! SyntaxCheckers_c_make_GetLocList() dict
let makeprg = self.getExecEscaped() . ' -sk'
let makeprg = self.makeprgBuild({ 'args': '-sk', 'fname': '' })
let errorformat =
\ '%-G%f:%s:,' .
@ -58,4 +58,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -8,13 +8,6 @@
" Want To Public License, Version 2, as published by Sam Hocevar.
" See http://sam.zoy.org/wtfpl/COPYING for more details.
"============================================================================
"
" The setting 'g:syntastic_oclint_config_file' allows you to define a file
" that contains additional compiler arguments like include directories or
" CFLAGS. The file is expected to contain one option per line. If none is
" given the filename defaults to '.syntastic_oclint_config':
"
" let g:syntastic_oclint_config_file = '.config'
if exists("g:loaded_syntastic_c_oclint_checker")
finish
@ -25,29 +18,41 @@ 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({
\ 'args_after': '-text',
\ 'post_args_before': '-- -c ' . syntastic#c#ReadConfig(g:syntastic_oclint_config_file) })
\ 'post_args': '-- -c ' . syntastic#c#ReadConfig(g:syntastic_oclint_config_file) })
let errorformat =
\ '%E%f:%l:%c: %m P1 ,' .
\ '%E%f:%l:%c: %m P2 ,' .
\ '%W%f:%l:%c: %m P3 ,' .
\ '%E%f:%l:%c: fatal error: %m,' .
\ '%E%f:%l:%c: error: %m,' .
\ '%W%f:%l:%c: warning: %m,' .
\ '%E%f:%l:%c: %m,' .
\ '%-G%.%#'
return SyntasticMake({
let loclist = SyntasticMake({
\ 'makeprg': makeprg,
\ 'errorformat': errorformat,
\ 'subtype': 'Style',
\ 'postprocess': ['compressWhitespace', 'sort'],
\ '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({
@ -57,4 +62,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -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 = findfile(g:syntastic_pc_lint_config_file, '.;')
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:

@ -8,13 +8,6 @@
" Want To Public License, Version 2, as published by Sam Hocevar.
" See http://sam.zoy.org/wtfpl/COPYING for more details.
"============================================================================
"
" The setting 'g:syntastic_sparse_config_file' allows you to define a file
" that contains additional compiler arguments like include directories or
" CFLAGS. The file is expected to contain one option per line. If none is
" given the filename defaults to '.syntastic_sparse_config':
"
" let g:syntastic_sparse_config_file = '.config'
if exists("g:loaded_syntastic_c_sparse_checker")
finish
@ -33,13 +26,15 @@ function! SyntaxCheckers_c_sparse_GetLocList() dict
\ '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 errorformat =
\ '%f:%l:%v: %trror: %m,' .
\ '%f:%l:%v: %tarning: %m,'
let loclist = SyntasticMake({
\ 'makeprg': makeprg,
\ 'errorformat': errorformat,
\ 'defaults': {'bufnr': bufnr("")},
\ 'returns': [0] })
\ 'returns': [0, 1] })
return loclist
endfunction
@ -50,4 +45,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -8,13 +8,6 @@
" Want To Public License, Version 2, as published by Sam Hocevar.
" See http://sam.zoy.org/wtfpl/COPYING for more details.
"============================================================================
"
" The setting 'g:syntastic_splint_config_file' allows you to define a file
" that contains additional compiler arguments like include directories or
" CFLAGS. The file is expected to contain one option per line. If none is
" given the filename defaults to '.syntastic_splint_config':
"
" let g:syntastic_splint_config_file = '.config'
if exists("g:loaded_syntastic_c_splint_checker")
finish
@ -35,8 +28,11 @@ function! SyntaxCheckers_c_splint_GetLocList() dict
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 %.%#'
@ -56,4 +52,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -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:

@ -36,4 +36,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -19,7 +19,8 @@ let s:save_cpo = &cpo
set cpo&vim
function! SyntaxCheckers_co_coco_GetLocList() dict
let makeprg = self.makeprgBuild({ 'args_after': '-c -o /tmp' })
let tmpdir = syntastic#util#tmpdir()
let makeprg = self.makeprgBuild({ 'args_after': '-c -o ' . tmpdir })
let errorformat =
\ '%EFailed at: %f,' .
@ -27,9 +28,13 @@ function! SyntaxCheckers_co_coco_GetLocList() dict
\ '%EFailed at: %f,'.
\ '%Z%trror: Parse error on line %l: %m'
return SyntasticMake({
let loclist = SyntasticMake({
\ 'makeprg': makeprg,
\ 'errorformat': errorformat })
call syntastic#util#rmrf(tmpdir)
return loclist
endfunction
call g:SyntasticRegistry.CreateAndRegisterChecker({
@ -39,4 +44,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -27,7 +27,8 @@ function! SyntaxCheckers_cobol_cobc_IsAvailable() dict
if !exists('g:syntastic_cobol_compiler')
let g:syntastic_cobol_compiler = self.getExec()
endif
return executable(expand(g:syntastic_cobol_compiler))
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
@ -43,4 +44,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -22,9 +22,11 @@ let s:save_cpo = &cpo
set cpo&vim
function! SyntaxCheckers_coffee_coffee_IsAvailable() dict
return executable(self.getExec()) &&
\ syntastic#util#versionIsAtLeast(syntastic#util#getVersion(
\ self.getExecEscaped() . ' --version 2>' . syntastic#util#DevNull()), [1,6,2])
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
@ -53,4 +55,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -19,7 +19,10 @@ let s:save_cpo = &cpo
set cpo&vim
function! SyntaxCheckers_coffee_coffeelint_GetLocList() dict
let makeprg = self.makeprgBuild({ 'args_after': '--csv' })
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\,%\d%#\,%trror\,%m,' .
@ -41,4 +44,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -37,4 +37,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

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

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

@ -8,13 +8,6 @@
" Want To Public License, Version 2, as published by Sam Hocevar.
" See http://sam.zoy.org/wtfpl/COPYING for more details.
"============================================================================
"
" The setting 'g:syntastic_cppcheck_config_file' allows you to define a file
" that contains additional compiler arguments like include directories or
" CFLAGS. The file is expected to contain one option per line. If none is
" given the filename defaults to '.syntastic_cppcheck_config':
"
" let g:syntastic_cppcheck_config_file = '.config'
if exists("g:loaded_syntastic_cpp_cppcheck_checker")
finish
@ -28,4 +21,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
\ 'name': 'cppcheck',
\ 'redirect': 'c/cppcheck'})
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -9,18 +9,6 @@
" See http://sam.zoy.org/wtfpl/COPYING for more details.
"
"============================================================================
"
" For details about cpplint see:
" https://code.google.com/p/google-styleguide/
"
" Checker options:
"
" - g:syntastic_cpp_cpplint_thres (integer; default: 5)
" error threshold: policy violations with a severity above this
" value are highlighted as errors, the others are warnings
"
" - g:syntastic_cpp_cpplint_args (string; default: '--verbose=3')
" command line options to pass to cpplint
if exists("g:loaded_syntastic_cpp_cpplint_checker")
finish
@ -61,4 +49,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -26,7 +26,8 @@ function! SyntaxCheckers_cpp_gcc_IsAvailable() dict
if !exists('g:syntastic_cpp_compiler')
let g:syntastic_cpp_compiler = executable(self.getExec()) ? self.getExec() : 'clang++'
endif
return executable(expand(g:syntastic_cpp_compiler))
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
@ -52,4 +53,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -8,13 +8,6 @@
" Want To Public License, Version 2, as published by Sam Hocevar.
" See http://sam.zoy.org/wtfpl/COPYING for more details.
"============================================================================
"
" The setting 'g:syntastic_oclint_config_file' allows you to define a file
" that contains additional compiler arguments like include directories or
" CFLAGS. The file is expected to contain one option per line. If none is
" given the filename defaults to '.syntastic_oclint_config':
"
" let g:syntastic_oclint_config_file = '.config'
if exists("g:loaded_syntastic_cpp_oclint_checker")
finish
@ -28,4 +21,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
\ 'name': 'oclint',
\ 'redirect': 'c/oclint'})
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

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

@ -36,4 +36,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -8,28 +8,19 @@
" Want To Public License, Version 2, as published by Sam Hocevar.
" See http://sam.zoy.org/wtfpl/COPYING for more details.
"============================================================================
"
" Specify additional options to csslint with this option. e.g. to disable
" warnings:
"
" let g:syntastic_csslint_options = '--warnings=none'
if exists('g:loaded_syntastic_css_csslint_checker')
finish
endif
let g:loaded_syntastic_css_csslint_checker = 1
if !exists('g:syntastic_csslint_options')
let g:syntastic_csslint_options = ''
endif
let s:save_cpo = &cpo
set cpo&vim
function! SyntaxCheckers_css_csslint_GetLocList() dict
let makeprg = self.makeprgBuild({
\ 'args': g:syntastic_csslint_options,
\ 'args_after': '--format=compact' })
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 =
@ -53,4 +44,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -9,10 +9,6 @@
" See http://sam.zoy.org/wtfpl/COPYING for more details.
"
"============================================================================
"
" See here for details of phpcs
" - phpcs (see http://pear.php.net/package/PHP_CodeSniffer)
"
if exists("g:loaded_syntastic_css_phpcs_checker")
finish
@ -26,4 +22,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
\ 'name': 'phpcs',
\ 'redirect': 'php/phpcs'})
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -9,24 +9,23 @@
" See http://sam.zoy.org/wtfpl/COPYING for more details.
"
"============================================================================
"
" For details about PrettyCSS see:
"
" - http://fidian.github.io/PrettyCSS/
" - https://github.com/fidian/PrettyCSS
if exists("g:loaded_syntastic_css_prettycss_checker")
finish
endif
let g:loaded_syntastic_css_prettycss_checker = 1
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' . term
let term = '\V' . escape(term, '\')
endif
return term
endfunction
@ -43,8 +42,7 @@ function! SyntaxCheckers_css_prettycss_GetLocList() dict
let loclist = SyntasticMake({
\ 'makeprg': makeprg,
\ 'errorformat': errorformat,
\ 'defaults': {'bufnr': bufnr("")},
\ 'postprocess': ['sort'] })
\ 'defaults': {'bufnr': bufnr("")} })
for e in loclist
let e["text"] .= ')'
@ -60,4 +58,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

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

@ -39,4 +39,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -6,18 +6,6 @@
"
"============================================================================
" in order to also check header files add this to your .vimrc:
" (this creates an empty .syntastic_dummy.cu file in your source directory)
"
" let g:syntastic_cuda_check_header = 1
" By default, nvcc and thus syntastic, defaults to the most basic architecture.
" This can produce false errors if the developer intends to compile for newer
" hardware and use newer features, eg. double precision numbers. To pass a
" specific target arch to nvcc, e.g. add the following to your .vimrc:
"
" let g:syntastic_cuda_arch = "sm_20"
if exists("g:loaded_syntastic_cuda_nvcc_checker")
finish
endif
@ -53,7 +41,7 @@ function! SyntaxCheckers_cuda_nvcc_GetLocList() dict
\ '%DMaking %*\a in %f,'.
\ '%f|%l| %m'
if expand('%') =~? '\m\%(.h\|.hpp\|.cuh\)$'
if expand('%', 1) =~? '\m\%(.h\|.hpp\|.cuh\)$'
if exists('g:syntastic_cuda_check_header')
let makeprg =
\ 'echo > .syntastic_dummy.cu ; ' .
@ -75,4 +63,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -31,10 +31,17 @@ function! SyntaxCheckers_d_dmd_IsAvailable() dict
if !exists('g:syntastic_d_compiler')
let g:syntastic_d_compiler = self.getExec()
endif
return executable(expand(g:syntastic_d_compiler))
call self.log('g:syntastic_d_compiler =', g:syntastic_d_compiler)
return executable(expand(g:syntastic_d_compiler, 1))
endfunction
function! SyntaxCheckers_d_dmd_GetLocList() dict
if !exists('g:syntastic_d_include_dirs')
let g:syntastic_d_include_dirs = filter(glob($HOME . '/.dub/packages/*', 1, 1), 'isdirectory(v:val)')
call map(g:syntastic_d_include_dirs, 'isdirectory(v:val . "/source") ? v:val . "/source" : v:val')
call add(g:syntastic_d_include_dirs, './source')
endif
return syntastic#c#GetLocList('d', 'dmd', {
\ 'errorformat':
\ '%-G%f:%s:,%f(%l): %m,' .
@ -50,4 +57,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -53,7 +53,7 @@ function! SyntaxCheckers_dart_dartanalyzer_GetLocList() dict
let loclist = SyntasticMake({
\ 'makeprg': makeprg,
\ 'errorformat': errorformat,
\ 'returns': [0, 1, 2] })
\ 'returns': [0, 1, 2, 3] })
for e in loclist
let e['text'] = substitute(e['text'], '\m\\\([\\|]\)', '\1', 'g')
@ -73,4 +73,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -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:

@ -22,4 +22,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
\ 'name': 'xmllint',
\ 'redirect': 'xml/xmllint'})
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -35,4 +35,4 @@ call SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -20,14 +20,22 @@ 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
if !exists('g:syntastic_enable_elixir_checker') || !g:syntastic_enable_elixir_checker
call syntastic#log#error('checker elixir/elixir: checks disabled for security reasons; ' .
\ 'set g:syntastic_enable_elixir_checker to 1 to override')
return []
endif
let make_options = {}
let compile_command = 'elixir'
let mix_file = syntastic#util#findInParent('mix.exs', expand('%:p:h'))
let mix_file = syntastic#util#findInParent('mix.exs', expand('%:p:h', 1))
if filereadable(mix_file)
let compile_command = 'mix compile'
@ -48,4 +56,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -2,10 +2,11 @@
-export([main/1]).
main([FileName]) ->
LibDirs = filelib:wildcard("{lib,deps}/*/ebin"),
LibDirs = (["ebin", "include", "src", "test"] ++
filelib:wildcard("{apps,deps,lib}/*/{ebin,include}")),
compile(FileName, LibDirs);
main([FileName | ["-rebar" | [Path | LibDirs]]]) ->
main([FileName, "-rebar", Path, LibDirs]) ->
{ok, L} = file:consult(Path),
P = dict:from_list(L),
Root = filename:dirname(Path),
@ -37,17 +38,19 @@ main([FileName | LibDirs]) ->
compile(FileName, LibDirs) ->
Root = get_root(filename:dirname(FileName)),
ok = code:add_pathsa(LibDirs),
compile:file(FileName, [warn_obsolete_guard,
warn_unused_import,
warn_shadow_vars,
warn_export_vars,
strong_validation,
report,
{i, filename:join(Root, "include")},
{i, filename:join(Root, "deps")},
{i, filename:join(Root, "apps")},
{i, filename:join(Root, "lib")}
]).
compile:file(FileName,
[warn_obsolete_guard,
warn_unused_import,
warn_shadow_vars,
warn_export_vars,
strong_validation,
report] ++
[{i, filename:join(Root, I)} || I <- LibDirs] ++
case lists:member("deps/pmod_transform/include", LibDirs) of
true -> [{parse_transform, pmod_pt}];
_ -> []
end
).
get_root(Dir) ->
Path = filename:split(filename:absname(Dir)),

@ -19,18 +19,18 @@ if !exists('g:syntastic_erlc_include_path')
let g:syntastic_erlc_include_path = ''
endif
let s:check_file = syntastic#util#shescape(expand('<sfile>:p:h') . syntastic#util#Slash() . 'erlang_check_file.erl')
let s: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') ==# 'hrl'
if expand('%:e', 1) ==# 'hrl'
return []
endif
let shebang = syntastic#util#parseShebang()
if shebang['exe'] =~# '\m\<escript$' || (shebang['exe'] ==# '/usr/bin/env' && shebang['args'][0] ==# 'escript')
if shebang['exe'] ==# 'escript'
let args = '-s'
let post_args = ''
else
@ -58,4 +58,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -38,3 +38,5 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set sw=4 sts=4 et fdm=marker:

@ -19,22 +19,22 @@ let s:save_cpo = &cpo
set cpo&vim
function! SyntaxCheckers_eruby_ruby_IsAvailable() dict
if !exists("g:syntastic_ruby_exec")
let g:syntastic_ruby_exec = self.getExec()
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(expand(g:syntastic_ruby_exec))
return executable(self.getExec())
endfunction
function! SyntaxCheckers_eruby_ruby_GetLocList() dict
let exe = syntastic#util#shexpand(g:syntastic_ruby_exec)
if !syntastic#util#isRunningWindows()
let exe = 'RUBYOPT= ' . exe
if !exists('s:ruby_new')
let s:ruby_new = syntastic#util#versionIsAtLeast(self.getVersion(), [1, 9])
endif
let fname = "'" . escape(expand('%'), "\\'") . "'"
let fname = "'" . escape(expand('%', 1), "\\'") . "'"
" TODO: encodings became useful in ruby 1.9 :)
if syntastic#util#versionIsAtLeast(syntastic#util#getVersion(exe . ' --version'), [1, 9])
if s:ruby_new
let enc = &fileencoding != '' ? &fileencoding : &encoding
let encoding_spec = ', :encoding => "' . (enc ==? 'utf-8' ? 'UTF-8' : 'BINARY') . '"'
else
@ -43,22 +43,32 @@ function! SyntaxCheckers_eruby_ruby_GetLocList() dict
"gsub fixes issue #7, rails has it's own eruby syntax
let makeprg =
\ exe . ' -rerb -e ' .
\ self.getExecEscaped() . ' -rerb -e ' .
\ syntastic#util#shescape('puts ERB.new(File.read(' .
\ fname . encoding_spec .
\ ').gsub(''<%='',''<%''), nil, ''-'').src') .
\ ' | ' . exe . ' -c'
\ ' | ' . self.getExecEscaped() . ' -w -c'
let errorformat =
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
@ -69,4 +79,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -26,7 +26,8 @@ function! SyntaxCheckers_fortran_gfortran_IsAvailable() dict
if !exists('g:syntastic_fortran_compiler')
let g:syntastic_fortran_compiler = self.getExec()
endif
return executable(expand(g:syntastic_fortran_compiler))
call self.log('g:syntastic_fortran_compiler = ', g:syntastic_fortran_compiler)
return executable(expand(g:syntastic_fortran_compiler, 1))
endfunction
function! SyntaxCheckers_fortran_gfortran_GetLocList() dict
@ -48,4 +49,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -27,7 +27,7 @@ let s:glsl_extensions = {
let s:save_cpo = &cpo
set cpo&vim
function! SyntaxCheckers_glsl_cgc_GetLocList() dict
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 : '') })
@ -39,9 +39,11 @@ function! SyntaxCheckers_glsl_cgc_GetLocList() dict
return SyntasticMake({
\ 'makeprg': makeprg,
\ 'errorformat': errorformat })
endfunction
endfunction " }}}1
function! s:GetProfile()
" Utilities {{{1
function! s:GetProfile() " {{{2
let save_view = winsaveview()
let old_foldenable = &foldenable
let old_lazyredraw = &lazyredraw
@ -61,11 +63,13 @@ function! s:GetProfile()
let profile = matchstr(getline(line), magic . '\zs.*')
else
let extensions = exists('g:syntastic_glsl_extensions') ? g:syntastic_glsl_extensions : s:glsl_extensions
let profile = get(extensions, tolower(expand('%:e')), 'gpu_vert')
let profile = get(extensions, tolower(expand('%:e', 1)), 'gpu_vert')
endif
return profile
endfunction
endfunction " }}}2
" }}}1
call g:SyntasticRegistry.CreateAndRegisterChecker({
\'filetype': 'glsl',
@ -74,4 +78,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -8,10 +8,11 @@
" 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
@ -22,7 +23,7 @@ let s:save_cpo = &cpo
set cpo&vim
function! SyntaxCheckers_go_go_IsAvailable() dict
return executable('go') && executable('gofmt')
return executable(self.getExec()) && executable('gofmt')
endfunction
function! SyntaxCheckers_go_go_GetLocList() dict
@ -48,13 +49,17 @@ function! SyntaxCheckers_go_go_GetLocList() dict
" Test files, i.e. files with a name ending in `_test.go`, are not
" compiled by `go build`, therefore `go test` must be called for those.
if match(expand('%'), '\m_test\.go$') == -1
let makeprg = 'go build ' . syntastic#c#NullOutput()
if match(expand('%', 1), '\m_test\.go$') == -1
let cmd = 'build'
let opts = syntastic#util#var('go_go_build_args')
let cleanup = 0
else
let makeprg = 'go test -c ' . syntastic#c#NullOutput()
let cmd = 'test -c'
let opts = syntastic#util#var('go_go_test_args')
let cleanup = 1
endif
let opt_str = (type(opts) != type('') || opts != '') ? join(syntastic#util#argsescape(opts)) : opts
let makeprg = self.getExec() . ' ' . cmd . ' ' . opt_str . ' ' . syntastic#c#NullOutput()
" The first pattern is for warnings from C compilers.
let errorformat =
@ -71,11 +76,11 @@ function! SyntaxCheckers_go_go_GetLocList() dict
let errors = SyntasticMake({
\ 'makeprg': makeprg,
\ 'errorformat': errorformat,
\ 'cwd': expand('%:p:h'),
\ 'cwd': expand('%:p:h', 1),
\ 'defaults': {'type': 'e'} })
if cleanup
call delete(expand('%:p:h') . syntastic#util#Slash() . expand('%:p:h:t') . '.test')
call delete(expand('%:p:h', 1) . syntastic#util#Slash() . expand('%:p:h:t', 1) . '.test')
endif
return errors
@ -88,4 +93,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -8,10 +8,11 @@
" 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
@ -41,4 +42,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -21,11 +21,14 @@ set cpo&vim
function! SyntaxCheckers_go_golint_GetLocList() dict
let makeprg = self.makeprgBuild({})
let errorformat = '%f:%l:%c: %m,%-G%.%#'
let errorformat =
\ '%f:%l:%c: %m,' .
\ '%-G%.%#'
return SyntasticMake({
\ 'makeprg': makeprg,
\ 'errorformat': errorformat,
\ 'defaults': {'type': 'w'},
\ 'subtype': 'Style' })
endfunction
@ -36,4 +39,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -29,13 +29,11 @@ function! SyntaxCheckers_go_gotype_GetLocList() dict
" the package for the same reasons specified in go.vim ("figuring out
" the import path is fickle").
let errors = SyntasticMake({
return SyntasticMake({
\ 'makeprg': makeprg,
\ 'errorformat': errorformat,
\ 'cwd': expand('%:p:h'),
\ 'cwd': expand('%:p:h', 1),
\ 'defaults': {'type': 'e'} })
return errors
endfunction
call g:SyntasticRegistry.CreateAndRegisterChecker({
@ -45,4 +43,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -19,31 +19,34 @@ let s:save_cpo = &cpo
set cpo&vim
function! SyntaxCheckers_go_govet_IsAvailable() dict
return executable('go')
return executable(self.getExec())
endfunction
function! SyntaxCheckers_go_govet_GetLocList() dict
let makeprg = 'go vet'
let errorformat = '%Evet: %.%\+: %f:%l:%c: %m,%W%f:%l: %m,%-G%.%#'
let makeprg = self.getExec() . ' vet'
let errorformat =
\ '%Evet: %.%\+: %f:%l:%c: %m,' .
\ '%W%f:%l: %m,' .
\ '%-G%.%#'
" The go compiler needs to either be run with an import path as an
" argument or directly from the package directory. Since figuring out
" the proper import path is fickle, just cwd to the package.
let errors = SyntasticMake({
return SyntasticMake({
\ 'makeprg': makeprg,
\ 'errorformat': errorformat,
\ 'cwd': expand('%:p:h'),
\ 'cwd': expand('%:p:h', 1),
\ 'defaults': {'type': 'w'} })
return errors
endfunction
call g:SyntasticRegistry.CreateAndRegisterChecker({
\ 'filetype': 'go',
\ 'name': 'govet'})
\ 'name': 'govet',
\ 'exec': 'go' })
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -19,16 +19,12 @@ let s:save_cpo = &cpo
set cpo&vim
function! SyntaxCheckers_haml_haml_IsAvailable() dict
if !exists('g:syntastic_haml_interpreter')
let g:syntastic_haml_interpreter = self.getExec()
endif
return executable(expand(g:syntastic_haml_interpreter))
call syntastic#log#deprecationWarn('haml_interpreter', 'haml_haml_exec')
return executable(self.getExec())
endfunction
function! SyntaxCheckers_haml_haml_GetLocList() dict
let makeprg = self.makeprgBuild({
\ 'exe': syntastic#util#shexpand(g:syntastic_haml_interpreter),
\ 'args_after': '-c' })
let makeprg = self.makeprgBuild({ 'args_after': '-c' })
let errorformat =
\ 'Haml error on line %l: %m,' .
@ -47,4 +43,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -34,4 +34,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -29,6 +29,7 @@ function! SyntaxCheckers_handlebars_handlebars_GetLocList() dict
return SyntasticMake({
\ 'makeprg': makeprg,
\ 'errorformat': errorformat,
\ 'postprocess': ['guards'],
\ 'defaults': {'bufnr': bufnr("")} })
endfunction
@ -39,4 +40,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -21,10 +21,33 @@ let s:save_cpo = &cpo
set cpo&vim
function! SyntaxCheckers_haskell_ghc_mod_IsAvailable() dict
" We need either a Vim version that can handle NULs in system() output,
" or a ghc-mod version that has the --boundary option.
let exe = self.getExec()
let s:ghc_mod_new = executable(exe) ? s:GhcModNew(exe) : -1
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 ver = filter(split(system(self.getExecEscaped() . ' version'), '\n'), 'v:val =~# ''\m\sversion''')
if !len(ver)
" That didn't work. Try "ghc-mod" alone.
let ver = filter(split(system(self.getExecEscaped()), '\n'), 'v:val =~# ''\m\sversion''')
endif
if len(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.
let parsed_ver = syntastic#util#parseVersion(ver[0])
call self.setVersion(parsed_ver)
let s:ghc_mod_new = syntastic#util#versionIsAtLeast(parsed_ver, [2, 1, 2])
else
call syntastic#log#error("checker haskell/ghc_mod: can't parse version string (abnormal termination?)")
let s:ghc_mod_new = -1
endif
return (s:ghc_mod_new >= 0) && (v:version >= 704 || s:ghc_mod_new)
endfunction
@ -49,18 +72,6 @@ function! SyntaxCheckers_haskell_ghc_mod_GetLocList() dict
\ 'returns': [0] })
endfunction
function! s:GhcModNew(exe)
let exe = syntastic#util#shescape(a:exe)
try
let ghc_mod_version = filter(split(system(exe), '\n'), 'v:val =~# ''\m^ghc-mod version''')[0]
let ret = syntastic#util#versionIsAtLeast(syntastic#util#parseVersion(ghc_mod_version), [2, 1, 2])
catch /^Vim\%((\a\+)\)\=:E684/
call syntastic#log#error("checker haskell/ghc_mod: can't parse version string (abnormal termination?)")
let ret = -1
endtry
return ret
endfunction
call g:SyntasticRegistry.CreateAndRegisterChecker({
\ 'filetype': 'haskell',
\ 'name': 'ghc_mod',
@ -69,4 +80,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -19,22 +19,30 @@ 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': self.getExecEscaped() . ' check',
\ 'args': get(g:, 'hdevtools_options', '') })
let errorformat= '\%-Z\ %#,'.
\ '%W%f:%l:%c:\ Warning:\ %m,'.
\ '%W%f:%l:%c:\ Warning:,'.
\ '%E%f:%l:%c:\ %m,'.
\ '%E%>%f:%l:%c:,'.
\ '%+C\ \ %#%m,'.
\ '%W%>%f:%l:%c:,'.
\ '%+C\ \ %#%tarning:\ %m,'
\ '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
@ -45,4 +53,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -14,16 +14,18 @@ let s:save_cpo = &cpo
set cpo&vim
function! SyntaxCheckers_haskell_hlint_GetLocList() dict
let makeprg = self.makeprgBuild({})
let makeprg = self.makeprgBuild({
\ 'fname': syntastic#util#shexpand('%:p')})
let errorformat =
\ '%E%f:%l:%c: Error: %m,' .
\ '%W%f:%l:%c: Warning: %m,' .
\ '%E%f:%l:%v: Error: %m,' .
\ '%W%f:%l:%v: Warning: %m,' .
\ '%C%m'
return SyntasticMake({
\ 'makeprg': makeprg,
\ 'errorformat': errorformat,
\ 'defaults': {'vcol': 1},
\ 'postprocess': ['compressWhitespace'] })
endfunction
@ -34,4 +36,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -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:

@ -24,10 +24,12 @@ function! SyntaxCheckers_haxe_haxe_GetLocList() dict
elseif exists('g:vaxe_hxml')
let hxml = g:vaxe_hxml
else
let hxml = syntastic#util#findInParent('*.hxml', expand('%:p:h'))
let hxml = syntastic#util#findInParent('*.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')) })
@ -58,4 +60,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -35,4 +35,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -14,35 +14,30 @@ if exists('g:loaded_syntastic_html_jshint_checker')
endif
let g:loaded_syntastic_html_jshint_checker = 1
if !exists('g:syntastic_jshint_exec')
let g:syntastic_jshint_exec = 'jshint'
endif
if !exists('g:syntastic_html_jshint_conf')
let g:syntastic_html_jshint_conf = ''
endif
let s:save_cpo = &cpo
set cpo&vim
function! SyntaxCheckers_html_jshint_IsAvailable() dict
let exe = expand(g:syntastic_jshint_exec)
return executable(exe) &&
\ syntastic#util#versionIsAtLeast(syntastic#util#getVersion(exe . ' --version'), [2,4])
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
let makeprg = self.makeprgBuild({
\ 'exe': expand(g:syntastic_jshint_exec),
\ 'args': (g:syntastic_html_jshint_conf != '' ? '--config ' . g:syntastic_html_jshint_conf : ''),
\ 'args_after': '--verbose --extract always' })
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('')} })
\ 'defaults': {'bufnr': bufnr('')},
\ 'returns': [0, 2] })
endfunction
call g:SyntasticRegistry.CreateAndRegisterChecker({
@ -52,4 +47,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -10,22 +10,24 @@
"
"============================================================================
"
" Checker option:
" Note: if you need to check HTML5 sources, you might consider installing a
" fork of HTML Tidy, named "HTML Tidy for HTML5":
"
" - g:syntastic_html_tidy_ignore_errors (list; default: [])
" list of errors to ignore
" - g:syntastic_html_tidy_blocklevel_tags (list; default: [])
" list of additional blocklevel tags, to be added to "--new-blocklevel-tags"
" - g:syntastic_html_tidy_inline_tags (list; default: [])
" list of additional inline tags, to be added to "--new-inline-tags"
" - g:syntastic_html_tidy_empty_tags (list; default: [])
" list of additional empty tags, to be added to "--new-empty-tags"
" http://w3c.github.io/tidy-html5/
"
" HTML Tidy for HTML5 can be used without changes by this checker, just install
" it and point g:syntastic_html_tidy_exec to the executable.
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
@ -42,141 +44,105 @@ if !exists('g:syntastic_html_tidy_empty_tags')
let g:syntastic_html_tidy_empty_tags = []
endif
let s:save_cpo = &cpo
set cpo&vim
" TODO: join this with xhtml.vim for DRY's sake?
function! s:TidyEncOptByFenc()
let tidy_opts = {
\'utf-8': '-utf8',
\'ascii': '-ascii',
\'latin1': '-latin1',
\'iso-2022-jp': '-iso-2022',
\'cp1252': '-win1252',
\'macroman': '-mac',
\'utf-16le': '-utf16le',
\'utf-16': '-utf16',
\'big5': '-big5',
\'cp932': '-shiftjis',
\'sjis': '-shiftjis',
\'cp850': '-ibm858',
\}
return get(tidy_opts, &fileencoding, '-utf8')
endfunction
let s:ignore_errors = [
\ "<table> lacks \"summary\" attribute",
\ "not approved by W3C",
\ "<input> proprietary attribute \"placeholder\"",
\ "<meta> proprietary attribute \"charset\"",
\ "<meta> lacks \"content\" attribute",
\ "inserting \"type\" attribute",
\ "proprietary attribute \"data-",
\ "missing <!DOCTYPE> declaration",
\ "inserting implicit <body>",
\ "inserting missing 'title' element",
\ "unescaped & or unknown entity",
\ "<input> attribute \"type\" has invalid value",
\ "proprietary attribute \"role\"",
\ "proprietary attribute \"aria-activedescendant\"",
\ "proprietary attribute \"aria-atomic\"",
\ "proprietary attribute \"aria-autocomplete\"",
\ "proprietary attribute \"aria-busy\"",
\ "proprietary attribute \"aria-checked\"",
\ "proprietary attribute \"aria-controls\"",
\ "proprietary attribute \"aria-describedby\"",
\ "proprietary attribute \"aria-disabled\"",
\ "proprietary attribute \"aria-dropeffect\"",
\ "proprietary attribute \"aria-expanded\"",
\ "proprietary attribute \"aria-flowto\"",
\ "proprietary attribute \"aria-grabbed\"",
\ "proprietary attribute \"aria-haspopup\"",
\ "proprietary attribute \"aria-hidden\"",
\ "proprietary attribute \"aria-invalid\"",
\ "proprietary attribute \"aria-label\"",
\ "proprietary attribute \"aria-labelledby\"",
\ "proprietary attribute \"aria-level\"",
\ "proprietary attribute \"aria-live\"",
\ "proprietary attribute \"aria-multiline\"",
\ "proprietary attribute \"aria-multiselectable\"",
\ "proprietary attribute \"aria-orientation\"",
\ "proprietary attribute \"aria-owns\"",
\ "proprietary attribute \"aria-posinset\"",
\ "proprietary attribute \"aria-pressed\"",
\ "proprietary attribute \"aria-readonly\"",
\ "proprietary attribute \"aria-relevant\"",
\ "proprietary attribute \"aria-relevant\"",
\ "proprietary attribute \"aria-required\"",
\ "proprietary attribute \"aria-selected\"",
\ "proprietary attribute \"aria-setsize\"",
\ "proprietary attribute \"aria-sort\"",
\ "proprietary attribute \"aria-valuemax\"",
\ "proprietary attribute \"aria-valuemin\"",
\ "proprietary attribute \"aria-valuenow\"",
\ "proprietary attribute \"aria-valuetext\""
\ ]
let s:blocklevel_tags = [
\ "main",
\ "section",
\ "article",
\ "aside",
\ "header",
\ "footer",
\ "nav",
\ "figure",
\ "figcaption"
\ ]
let s:inline_tags = [
\ "video",
\ "audio",
\ "source",
\ "embed",
\ "mark",
\ "progress",
\ "meter",
\ "time",
\ "ruby",
\ "rt",
\ "rp",
\ "canvas",
\ "command",
\ "details",
\ "datalist"
\ ]
let s:empty_tags = [
\ "wbr",
\ "keygen"
\ ]
function! s:IgnoreError(text)
for i in s:ignore_errors + g:syntastic_html_tidy_ignore_errors
if stridx(a:text, i) != -1
return 1
endif
endfor
return 0
endfunction
function! s:NewTags(name)
return syntastic#util#shescape(join( s:{a:name} + g:syntastic_html_tidy_{a:name}, ',' ))
endfunction
function! s:Args()
let args = s:TidyEncOptByFenc() .
\ ' --new-blocklevel-tags ' . s:NewTags('blocklevel_tags') .
\ ' --new-inline-tags ' . s:NewTags('inline_tags') .
\ ' --new-empty-tags ' . s:NewTags('empty_tags') .
\ ' -e'
return args
endfunction
function! SyntaxCheckers_html_tidy_GetLocList() dict
let makeprg = self.makeprgBuild({
\ 'args_after': s:Args(),
\ 'tail': '2>&1' })
" }}}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,' .
@ -197,7 +163,52 @@ function! SyntaxCheckers_html_tidy_GetLocList() dict
endfor
return loclist
endfunction
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',
@ -206,4 +217,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -9,24 +9,6 @@
" See http://sam.zoy.org/wtfpl/COPYING for more details.
"
"============================================================================
"
" For detail;s about validator see: http://about.validator.nu/
"
" Checker options:
"
" - g:syntastic_html_validator_api (string; default: 'http://validator.nu/')
" URL of the service to use for checking; leave it to the default to run the
" checks against http://validator.nu/, or set it to 'http://localhost:8888/'
" if you're running a local service as per http://about.validator.nu/#src
"
" - g:syntastic_html_validator_parser (string; default: empty)
" parser to use; legal values are: xml, xmldtd, html, html5, html4, html4tr;
" set it to 'html5' to check HTML5 files; see the wiki for reference:
" http://wiki.whatwg.org/wiki/Validator.nu_Common_Input_Parameters#parser
"
" - g:syntastic_html_validator_nsfilter (string; default: empty)
" sets the nsfilter for the parser; see the wiki for details:
" http://wiki.whatwg.org/wiki/Validator.nu_Common_Input_Parameters#nsfilter
if exists("g:loaded_syntastic_html_validator_checker")
finish
@ -48,24 +30,9 @@ endif
let s:save_cpo = &cpo
set cpo&vim
function! SyntaxCheckers_html_validator_Preprocess(errors)
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
function! SyntaxCheckers_html_validator_GetLocList() dict
let fname = syntastic#util#shexpand('%')
let makeprg = self.getExecEscaped() . ' -s --compressed -F out=gnu -F asciiquotes=yes' .
let makeprg = self.getExecEscaped() . ' -q -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
@ -87,7 +54,7 @@ function! SyntaxCheckers_html_validator_GetLocList() dict
return SyntasticMake({
\ 'makeprg': makeprg,
\ 'errorformat': errorformat,
\ 'preprocess': 'SyntaxCheckers_html_validator_Preprocess',
\ 'preprocess': 'validator',
\ 'returns': [0] })
endfunction
@ -99,4 +66,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -9,13 +9,6 @@
" See http://sam.zoy.org/wtfpl/COPYING for more details.
"
"============================================================================
"
" Checker option:
"
" - g:syntastic_html_w3_api (string; default: 'http://validator.w3.org/check')
" URL of the service to use for checking; leave it to the default to run the
" checks against http://validator.w3.org/, or set it to
" 'http://localhost/w3c-validator/check' if you're running a local service
if exists("g:loaded_syntastic_html_w3_checker")
finish
@ -30,7 +23,7 @@ let s:save_cpo = &cpo
set cpo&vim
function! SyntaxCheckers_html_w3_GetLocList() dict
let makeprg = self.getExecEscaped() . ' -s -F output=json ' .
let makeprg = self.getExecEscaped() . ' -q -s -F output=json ' .
\ '-F uploaded_file=@' . syntastic#util#shexpand('%:p') . '\;type=text/html ' .
\ g:syntastic_html_w3_api
@ -66,4 +59,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -27,45 +27,34 @@ endif
let s:save_cpo = &cpo
set cpo&vim
function! SyntaxCheckers_java_checkstyle_Preprocess(errors)
let out = []
let fname = expand('%')
for err in a:errors
if match(err, '\m<error\>') > -1
let line = str2nr(matchstr(err, '\m\<line="\zs\d\+\ze"'))
if line == 0
continue
endif
let col = str2nr(matchstr(err, '\m\<column="\zs\d\+\ze"'))
let type = matchstr(err, '\m\<severity="\zs.\ze')
if type !~? '^[EW]'
let type = 'E'
endif
let message = syntastic#util#decodeXMLEntities(matchstr(err, '\m\<message="\zs[^"]\+\ze"'))
call add(out, join([fname, type, line, col, message], ':'))
elseif match(err, '\m<file name="') > -1
let fname = syntastic#util#decodeXMLEntities(matchstr(err, '\v\<file name\="\zs[^"]+\ze"'))
endif
endfor
return out
function! SyntaxCheckers_java_checkstyle_IsAvailable() dict
if !executable(self.getExec())
return 0
endif
let classpath = expand(g:syntastic_java_checkstyle_classpath, 1)
let conf_file = expand(g:syntastic_java_checkstyle_conf_file, 1)
call self.log(
\ 'filereadable(' . string(classpath) . ') = ' . filereadable(classpath) . ', ' .
\ 'filereadable(' . string(conf_file) . ') = ' . filereadable(conf_file))
return filereadable(classpath) && filereadable(conf_file)
endfunction
function! SyntaxCheckers_java_checkstyle_GetLocList() dict
let fname = syntastic#util#shescape( expand('%:p:h') . '/' . expand('%:t') )
let fname = syntastic#util#shescape( expand('%:p:h', 1) . syntastic#util#Slash() . expand('%:t', 1) )
if has('win32unix')
let fname = substitute(system('cygpath -m ' . fname), '\m\%x00', '', 'g')
endif
let makeprg = self.makeprgBuild({
\ 'args_after': '-cp ' . g:syntastic_java_checkstyle_classpath .
\ ' com.puppycrawl.tools.checkstyle.Main -c ' . g:syntastic_java_checkstyle_conf_file .
\ ' -f xml',
\ 'args_after': [
\ '-cp', expand(g:syntastic_java_checkstyle_classpath, 1),
\ 'com.puppycrawl.tools.checkstyle.Main',
\ '-c', expand(g:syntastic_java_checkstyle_conf_file, 1),
\ '-f', 'xml'],
\ 'fname': fname })
let errorformat = '%f:%t:%l:%c:%m'
@ -73,8 +62,8 @@ function! SyntaxCheckers_java_checkstyle_GetLocList() dict
return SyntasticMake({
\ 'makeprg': makeprg,
\ 'errorformat': errorformat,
\ 'subtype': 'Style',
\ 'preprocess': 'SyntaxCheckers_java_checkstyle_Preprocess' })
\ 'preprocess': 'checkstyle',
\ 'subtype': 'Style' })
endfunction
call g:SyntasticRegistry.CreateAndRegisterChecker({
@ -85,4 +74,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -10,53 +10,44 @@
" See http://sam.zoy.org/wtfpl/COPYING for more details.
"============================================================================
if exists("g:loaded_syntastic_java_javac_checker")
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_tags = ['build', 'properties']
let g:syntastic_java_javac_maven_pom_properties = {}
let s:has_maven = 0
" Global Options
if !exists("g:syntastic_java_javac_executable")
let 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")
if !exists('g:syntastic_java_maven_executable')
let g:syntastic_java_maven_executable = 'mvn'
endif
if !exists("g:syntastic_java_javac_options")
if !exists('g:syntastic_java_javac_options')
let g:syntastic_java_javac_options = '-Xlint'
endif
if !exists("g:syntastic_java_javac_classpath")
let g:syntastic_java_javac_classpath = ''
if !exists('g:syntastic_java_maven_options')
let g:syntastic_java_maven_options = ''
endif
if !exists("g:syntastic_java_javac_delete_output")
let g:syntastic_java_javac_delete_output = 1
if !exists('g:syntastic_java_javac_classpath')
let g:syntastic_java_javac_classpath = ''
endif
let s:save_cpo = &cpo
set cpo&vim
function! s:CygwinPath(path)
return substitute(system("cygpath -m " . a:path), '\n', '', 'g')
endfunction
if !exists("g:syntastic_java_javac_temp_dir")
if has('win32') || has('win64')
let g:syntastic_java_javac_temp_dir = $TEMP."\\vim-syntastic-javac"
elseif has('win32unix')
let g:syntastic_java_javac_temp_dir = s:CygwinPath('/tmp/vim-syntastic-javac')
else
let g:syntastic_java_javac_temp_dir = '/tmp/vim-syntastic-javac'
endif
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")
if !exists('g:syntastic_java_javac_autoload_maven_classpath')
let g:syntastic_java_javac_autoload_maven_classpath = 1
endif
@ -72,63 +63,152 @@ 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")
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")
if !exists('g:syntastic_java_javac_maven_pom_classpath')
let g:syntastic_java_javac_maven_pom_classpath = {}
endif
function! s:RemoveCarriageReturn(line)
return substitute(a:line, '\r', '', 'g')
endfunction
" }}}1
" recursively remove directory and all it's sub-directories
function! s:RemoveDir(dir)
if isdirectory(a:dir)
for f in split(globpath(a:dir, '*'), "\n")
call s:RemoveDir(f)
endfor
silent! call system('rmdir ' . a:dir)
else
silent! call delete(a:dir)
command! SyntasticJavacEditClasspath call s:EditClasspath()
if g:syntastic_java_javac_config_file_enabled
command! SyntasticJavacEditConfig call s:EditConfig()
endif
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
endfunction
function! s:AddToClasspath(classpath, path)
if a:path == ''
return a:classpath
" load classpath from config file
if g:syntastic_java_javac_config_file_enabled
call s:LoadConfigFile()
endif
if a:classpath != '' && a:path != ''
if has('win32') || has('win32unix') || has('win64')
return a:classpath . ";" . a:path
else
return a:classpath . ":" . a:path
" 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
else
return a:path
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
endfunction
" }}}2
function! s:SplitClasspath(classpath)
if a:classpath == ''
return []
" load custom classpath {{{2
if g:syntastic_java_javac_custom_classpath_command != ''
let lines = system(g:syntastic_java_javac_custom_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 has('win32') || has('win32unix') || has('win64')
return split(a:classpath, ";")
else
return split(a:classpath, ":")
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 = s: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,'.
\ '%A%f:%l:\ %m,'.
\ '%+Z%p^,'.
\ '%+C%.%#,'.
\ '%-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:CygwinPath(path) " {{{2
return substitute(system('cygpath -m ' . syntastic#util#shescape(a:path)), "\n", '', 'g')
endfunction " }}}2
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
endfunction
return (a:classpath != '') ? a:classpath . s:ClassSep() . a:path : a:path
endfunction " }}}2
function! s:LoadConfigFile()
if filereadable(g:syntastic_java_javac_config_file)
exe 'source '.g:syntastic_java_javac_config_file
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
endfunction " }}}2
function! s:SaveClasspath()
function! s:SaveClasspath() " {{{2
" build classpath from lines
let path = ''
let lines = getline(1, line('$'))
@ -137,39 +217,39 @@ function! s:SaveClasspath()
endfor
" save classpath to config file
if g:syntastic_java_javac_config_file_enabled
if filereadable(g:syntastic_java_javac_config_file)
if filereadable(expand(g:syntastic_java_javac_config_file, 1))
" load lines from config file
let lines = readfile(g:syntastic_java_javac_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)
let i -= 1
else
let i += 1
endif
let i += 1
endwhile
else
let lines = []
endif
" add new g:syntastic_java_javac_classpath option to config
call add(lines, 'let g:syntastic_java_javac_classpath = "'.path.'"')
call add(lines, 'let g:syntastic_java_javac_classpath = ' . string(path))
" save config file lines
call writefile(lines, g:syntastic_java_javac_config_file)
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
endfunction " }}}2
function! s:EditClasspath()
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
let path += s:SplitClasspath(p)
call extend(path, s:SplitClasspath(p))
endfor
execute (len(path) + 5) . 'sp ' . fnameescape(command)
@ -185,25 +265,25 @@ function! s:EditClasspath()
else
execute winnr . 'wincmd w'
endif
endfunction
endfunction " }}}2
function! s:SaveConfig()
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, g:syntastic_java_javac_config_file)
call writefile(lines, expand(g:syntastic_java_javac_config_file, 1))
endif
let &modified = 0
endfunction
endfunction " }}}2
function! s:EditConfig()
function! s:EditConfig() " {{{2
let command = 'syntastic javac config'
let winnr = bufwinnr('^' . command . '$')
if winnr < 0
let lines = []
if filereadable(g:syntastic_java_javac_config_file)
let lines = readfile(g:syntastic_java_javac_config_file)
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)
@ -219,14 +299,16 @@ function! s:EditConfig()
else
execute winnr . 'wincmd w'
endif
endfunction
endfunction " }}}2
function! s:GetMavenProperties()
function! s:GetMavenProperties() " {{{2
let mvn_properties = {}
let pom = findfile("pom.xml", ".;")
let pom = findfile('pom.xml', '.;')
if s:has_maven && filereadable(pom)
if !has_key(g:syntastic_java_javac_maven_pom_properties, pom)
let mvn_cmd = syntastic#util#shexpand(g:syntastic_java_maven_executable) . ' -f ' . pom
let mvn_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(system(mvn_cmd . ' help:effective-pom'), "\n")
let current_path = 'project'
@ -239,7 +321,7 @@ function! s:GetMavenProperties()
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] . "$", '', '')
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)
@ -253,19 +335,15 @@ function! s:GetMavenProperties()
return g:syntastic_java_javac_maven_pom_properties[pom]
endif
return mvn_properties
endfunction
command! SyntasticJavacEditClasspath call s:EditClasspath()
if g:syntastic_java_javac_config_file_enabled
command! SyntasticJavacEditConfig call s:EditConfig()
endif
endfunction " }}}2
function! s:GetMavenClasspath()
let pom = findfile("pom.xml", ".;")
function! s:GetMavenClasspath() " {{{2
let pom = findfile('pom.xml', '.;')
if s:has_maven && filereadable(pom)
if !has_key(g:syntastic_java_javac_maven_pom_ftime, pom) || g:syntastic_java_javac_maven_pom_ftime[pom] != getftime(pom)
let mvn_cmd = syntastic#util#shexpand(g:syntastic_java_maven_executable) . ' -f ' . pom
let mvn_cmd = syntastic#util#shexpand(g:syntastic_java_maven_executable) .
\ ' -f ' . syntastic#util#shescape(pom) .
\ ' ' . g:syntastic_java_maven_options
let mvn_classpath_output = split(system(mvn_cmd . ' dependency:build-classpath'), "\n")
let mvn_classpath = ''
let class_path_next = 0
@ -300,28 +378,23 @@ function! s:GetMavenClasspath()
return g:syntastic_java_javac_maven_pom_classpath[pom]
endif
return ''
endfunction
function! SyntaxCheckers_java_javac_IsAvailable() dict
let s:has_maven = executable(expand(g:syntastic_java_maven_executable))
return executable(expand(g:syntastic_java_javac_executable))
endfunction
endfunction " }}}2
function! s:MavenOutputDirectory()
let pom = findfile("pom.xml", ".;")
function! s:MavenOutputDirectory() " {{{2
let pom = findfile('pom.xml', '.;')
if s:has_maven && filereadable(pom)
let mvn_properties = s:GetMavenProperties()
let output_dir = getcwd()
if has_key(mvn_properties, 'project.properties.build.dir')
let output_dir = mvn_properties['project.properties.build.dir']
endif
if stridx(expand( '%:p:h' ), "src.main.java") >= 0
if stridx(expand('%:p:h', 1), 'src.main.java') >= 0
let output_dir .= '/target/classes'
if has_key(mvn_properties, 'project.build.outputDirectory')
let output_dir = mvn_properties['project.build.outputDirectory']
endif
endif
if stridx(expand( '%:p:h' ), "src.test.java") >= 0
if stridx(expand('%:p:h', 1), 'src.test.java') >= 0
let output_dir .= '/target/test-classes'
if has_key(mvn_properties, 'project.build.testOutputDirectory')
let output_dir = mvn_properties['project.build.testOutputDirectory']
@ -329,116 +402,14 @@ function! s:MavenOutputDirectory()
endif
if has('win32unix')
let output_dir=s:CygwinPath(output_dir)
let output_dir = s:CygwinPath(output_dir)
endif
return output_dir
endif
return '.'
endfunction
function! SyntaxCheckers_java_javac_GetLocList() dict
let javac_opts = g:syntastic_java_javac_options
let output_dir = ""
if g:syntastic_java_javac_delete_output
let output_dir = g:syntastic_java_javac_temp_dir
let javac_opts .= ' -d ' . output_dir
endif
" load classpath from config file
if g:syntastic_java_javac_config_file_enabled
call s:LoadConfigFile()
endif
let javac_classpath = ''
" add classpathes to javac_classpath
if has('win32') || has('win32unix') || has('win64')
let javac_classpath_split = ';'
else
let javac_classpath_split = ':'
endif
for path in split(g:syntastic_java_javac_classpath, javac_classpath_split)
if path != ''
try
let ps = glob(path, 0, 1)
catch
let ps = split(glob(path, 0), "\n")
endtry
if type(ps) == type([])
for p in ps
let javac_classpath = s:AddToClasspath(javac_classpath, p)
endfor
else
let javac_classpath = s:AddToClasspath(javac_classpath, ps)
endif
endif
endfor
if s:has_maven && g:syntastic_java_javac_autoload_maven_classpath
if !g:syntastic_java_javac_delete_output
let javac_opts .= ' -d ' . s:MavenOutputDirectory()
endif
let javac_classpath = s:AddToClasspath(javac_classpath, s:GetMavenClasspath())
endif
" load custom classpath
if g:syntastic_java_javac_custom_classpath_command != ''
let lines = system(g:syntastic_java_javac_custom_classpath_command)
if has('win32') || has('win32unix') || has('win64')
let lines = substitute(lines, "\r\n", "\n", 'g')
endif
for l in split(lines, "\n")
let javac_classpath = s:AddToClasspath(javac_classpath, l)
endfor
endif
if javac_classpath != ''
let javac_opts .= ' -cp "' . fnameescape(javac_classpath) . '"'
endif
" path seperator
if has('win32') || has('win32unix') || has('win64')
let sep = "\\"
else
let sep = '/'
endif
let fname = fnameescape(expand ( '%:p:h' ) . sep . expand ( '%:t' ))
if has('win32unix')
let fname = s:CygwinPath(fname)
endif
let makeprg = self.makeprgBuild({
\ 'args': javac_opts,
\ 'fname': fname,
\ 'tail': '2>&1' })
" unashamedly stolen from *errorformat-javac* (quickfix.txt) and modified to include error types
let errorformat =
\ '%E%f:%l:\ error:\ %m,'.
\ '%W%f:%l:\ warning:\ %m,'.
\ '%A%f:%l:\ %m,'.
\ '%+Z%p^,'.
\ '%+C%.%#,'.
\ '%-G%.%#'
if g:syntastic_java_javac_delete_output
silent! call mkdir(output_dir, 'p')
endif
let errors = SyntasticMake({
\ 'makeprg': makeprg,
\ 'errorformat': errorformat,
\ 'postprocess': ['cygwinRemoveCR'] })
if g:syntastic_java_javac_delete_output
call s:RemoveDir(output_dir)
endif
return errors
endfunction " }}}2
endfunction
" }}}1
call g:SyntasticRegistry.CreateAndRegisterChecker({
\ 'filetype': 'java',
@ -447,4 +418,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -8,55 +8,55 @@
" Want To Public License, Version 2, as published by Sam Hocevar.
" See http://sam.zoy.org/wtfpl/COPYING for more details.
"============================================================================
"
" To enable this plugin, edit the .vimrc like this:
"
" let g:syntastic_javascript_checker = "closurecompiler"
"
" and set the path to the Google Closure Compiler:
"
" let g:syntastic_javascript_closure_compiler_path = '/path/to/google-closure-compiler.jar'
"
" It takes additional options for Google Closure Compiler with the variable
" g:syntastic_javascript_closure_compiler_options.
"
if exists("g:loaded_syntastic_javascript_closurecompiler_checker")
finish
endif
let g:loaded_syntastic_javascript_closurecompiler_checker = 1
if !exists("g:syntastic_javascript_closure_compiler_options")
let g:syntastic_javascript_closure_compiler_options = ""
endif
let s:save_cpo = &cpo
set cpo&vim
function! SyntaxCheckers_javascript_closurecompiler_IsAvailable() dict
return
\ executable("java") &&
\ exists("g:syntastic_javascript_closure_compiler_path") &&
\ filereadable(g:syntastic_javascript_closure_compiler_path)
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
if exists("g:syntastic_javascript_closure_compiler_file_list")
let file_list = join(readfile(g:syntastic_javascript_closure_compiler_file_list))
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 = syntastic#util#shexpand('%')
let file_list = [expand('%', 1)]
endif
let makeprg = self.makeprgBuild({
\ 'exe': 'java -jar ' . g:syntastic_javascript_closure_compiler_path,
\ 'args': g:syntastic_javascript_closure_compiler_options,
\ 'args_after': '--js' ,
\ '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,'.
\ '%Z%p^,'.
\ '%W%f:%l: WARNING - %m,'.
\ '%Z%p^'
@ -68,9 +68,9 @@ endfunction
call g:SyntasticRegistry.CreateAndRegisterChecker({
\ 'filetype': 'javascript',
\ 'name': 'closurecompiler',
\ 'exec': 'java'})
\ 'exec': get(g:, 'syntastic_javascript_closurecompiler_script', 'java')})
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -14,24 +14,34 @@ if exists('g:loaded_syntastic_javascript_eslint_checker')
endif
let g:loaded_syntastic_javascript_eslint_checker = 1
if !exists('g:syntastic_javascript_eslint_conf')
let g:syntastic_javascript_eslint_conf = ''
if !exists('g:syntastic_javascript_eslint_sort')
let g:syntastic_javascript_eslint_sort = 1
endif
let s:save_cpo = &cpo
set cpo&vim
function! SyntaxCheckers_javascript_eslint_IsAvailable() dict
if !executable(self.getExec())
return 0
endif
return syntastic#util#versionIsAtLeast(self.getVersion(), [0, 1])
endfunction
function! SyntaxCheckers_javascript_eslint_GetLocList() dict
let makeprg = self.makeprgBuild({
\ 'args': (g:syntastic_javascript_eslint_conf != '' ? '--config ' . g:syntastic_javascript_eslint_conf : '') })
call syntastic#log#deprecationWarn('javascript_eslint_conf', 'javascript_eslint_args',
\ "'--config ' . syntastic#util#shexpand(OLD_VAR)")
let makeprg = self.makeprgBuild({ 'args_before': '-f compact' })
let errorformat =
\ '%E%f: line %l\, col %c\, Error - %m'
\ '%E%f: line %l\, col %c\, Error - %m,' .
\ '%W%f: line %l\, col %c\, Warning - %m'
let loclist = SyntasticMake({
\ 'makeprg': makeprg,
\ 'errorformat': errorformat,
\ 'postprocess': ['sort'] })
\ 'postprocess': ['guards'] })
for e in loclist
let e['col'] += 1
@ -47,4 +57,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -0,0 +1,56 @@
"============================================================================
"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_GetLocList() dict
let makeprg = self.makeprgBuild({
\ 'exe_after': '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:

@ -14,16 +14,13 @@ if exists("g:loaded_syntastic_javascript_gjslint_checker")
endif
let g:loaded_syntastic_javascript_gjslint_checker = 1
if !exists("g:syntastic_javascript_gjslint_conf")
let g:syntastic_javascript_gjslint_conf = ""
endif
let s:save_cpo = &cpo
set cpo&vim
function! SyntaxCheckers_javascript_gjslint_GetLocList() dict
call syntastic#log#deprecationWarn('javascript_gjslint_conf', 'javascript_gjslint_args')
let makeprg = self.makeprgBuild({
\ 'args': g:syntastic_javascript_gjslint_conf,
\ 'args_after': '--nosummary --unix_mode --nodebug_indentation --nobeep' })
let errorformat =
@ -45,4 +42,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -14,22 +14,24 @@ if exists("g:loaded_syntastic_javascript_jscs_checker")
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
" we borrow SyntaxCheckers_java_checkstyle_Preprocess() from java/checkstyle
runtime! syntax_checkers/java/*.vim
function! SyntaxCheckers_javascript_jscs_GetLocList() dict
let makeprg = self.makeprgBuild({ 'args_after': '--no-colors --reporter checkstyle' })
let errorformat = '%f:%t:%l:%c:%m'
return SyntasticMake({
\ 'makeprg': makeprg,
\ 'errorformat': errorformat,
\ 'subtype': 'Style',
\ 'preprocess': 'SyntaxCheckers_java_checkstyle_Preprocess',
\ 'postprocess': ['sort'],
\ 'returns': [0] })
\ 'preprocess': 'checkstyle',
\ 'returns': [0, 2] })
endfunction
call g:SyntasticRegistry.CreateAndRegisterChecker({
@ -39,4 +41,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -14,31 +14,30 @@ if exists('g:loaded_syntastic_javascript_jshint_checker')
endif
let g:loaded_syntastic_javascript_jshint_checker = 1
if !exists('g:syntastic_javascript_jshint_conf')
let g:syntastic_javascript_jshint_conf = ''
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
if !exists('g:syntastic_jshint_exec')
let g:syntastic_jshint_exec = self.getExec()
call syntastic#log#deprecationWarn('jshint_exec', 'javascript_jshint_exec')
if !executable(self.getExec())
return 0
endif
return executable(expand(g:syntastic_jshint_exec))
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
let exe = syntastic#util#shexpand(g:syntastic_jshint_exec)
if !exists('s:jshint_new')
let s:jshint_new =
\ syntastic#util#versionIsAtLeast(syntastic#util#getVersion(exe . ' --version'), [1, 1])
endif
call syntastic#log#deprecationWarn('javascript_jshint_conf', 'javascript_jshint_args',
\ "'--config ' . syntastic#util#shexpand(OLD_VAR)")
let makeprg = self.makeprgBuild({
\ 'exe': exe,
\ 'args': (g:syntastic_javascript_jshint_conf != '' ? '--config ' . g:syntastic_javascript_jshint_conf : ''),
\ 'args_after': (s:jshint_new ? '--verbose ' : '') })
let makeprg = self.makeprgBuild({ 'args_after': (s:jshint_new ? '--verbose ' : '') })
let errorformat = s:jshint_new ?
\ '%A%f: line %l\, col %v\, %m \(%t%*\d\)' :
@ -47,7 +46,8 @@ function! SyntaxCheckers_javascript_jshint_GetLocList() dict
return SyntasticMake({
\ 'makeprg': makeprg,
\ 'errorformat': errorformat,
\ 'defaults': {'bufnr': bufnr('')} })
\ 'defaults': {'bufnr': bufnr('')},
\ 'returns': [0, 2] })
endfunction
call g:SyntasticRegistry.CreateAndRegisterChecker({
@ -57,4 +57,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -14,16 +14,14 @@ if exists("g:loaded_syntastic_javascript_jsl_checker")
endif
let g:loaded_syntastic_javascript_jsl_checker = 1
if !exists("g:syntastic_javascript_jsl_conf")
let g:syntastic_javascript_jsl_conf = ""
endif
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': (g:syntastic_javascript_jsl_conf != '' ? '-conf ' . g:syntastic_javascript_jsl_conf : ''),
\ 'args_after': '-nologo -nofilelisting -nosummary -nocontext -process' })
let errorformat =
@ -47,4 +45,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -8,8 +8,8 @@
" Want To Public License, Version 2, as published by Sam Hocevar.
" See http://sam.zoy.org/wtfpl/COPYING for more details.
"
"Tested with jslint 0.1.4.
"============================================================================
if exists("g:loaded_syntastic_javascript_jslint_checker")
finish
endif
@ -22,7 +22,7 @@ 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' . term
let term = '\V\<' . escape(term, '\') . '\>'
endif
return term
endfunction
@ -48,4 +48,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

@ -0,0 +1,51 @@
"============================================================================
"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
let jsxhint_version = system(self.getExecEscaped() . ' --version')
if v:shell_error || (jsxhint_version !~# '\m^JSXHint\>')
return 0
endif
let ver = syntastic#util#parseVersion(jsxhint_version)
call self.setVersion(ver)
return syntastic#util#versionIsAtLeast(ver, [0, 4, 1])
endfunction
function! SyntaxCheckers_javascript_jsxhint_GetLocList() dict
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
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:

@ -40,4 +40,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set et sts=4 sw=4:
" vim: set sw=4 sts=4 et fdm=marker:

Some files were not shown because too many files have changed in this diff Show More

Loading…
Cancel
Save