See what Vim `:!` executes

Question

Between

• :%!
• exe "!..."
• exe "!bash -c" shellescape(...)

I'm getting quite confused as to what exactly Vim invokes. And I suspect at some point it invokes bash -c bash .... Is there a way to see exactly what shell command is being called out? Does Vim ever invoke directly the command after !, or does it always wrap the command in bash -c ...?

I'm really trying to invoke a shell command, stored in g:cmd, which has a % in it, with as little overhead as possible (i.e., no bash -c bash). It's supposed to act as a filter on the visual selection. But

exe "'<,'>!" g:cmd  # Substitutes '%'
exe "'<,'>! bash -c" shellescape( g:cmd, 1 )  # Maybe wraps 2x bash around
exe "'<,'>!" shellescape( g:cmd, 1/0 )  # Bash calls g:cmd as executable -> error

Answer 1

When you use ! or :! Vim builds the invoking command based on whatever is specified in the various 'shell...' settings (i.e. 'shell', 'shellcmdflag', 'shellquote', to name three). On Unix systems the defaults for the first two are usually the default shell ($SHELL) and -c so if I'm using Bash and I do :!foo bar the call Vim makes will look like:

/bin/bash -c "foo bar"

So, to answer your question: No, Vim never directly calls the command after !.

---

The above answers the one concrete question I saw in the question's text but as we sussed out in the comments there was also a question about how to debug things in this situation. For the benefit of other readers I'll repeat here what I suggested:

A good way to get insight into what exactly gets passed by Vim to the 'shell' program is to write your own "shell". By which I mean write a wrapper script which contains whatever you want. The most obvious thing to do is just have it print all the params/args received. Now set 'shell' to point to that instead of /bin/bash or whatever it's currently pointing to, make a :! call and start debugging.

Answer 2

Is there a way to see exactly what shell command is being called out?

To see what exactly is run,

:echo getpid()

will show vim's PID, e.g. 1234, with which you can then in another terminal run:

sudo strace -fe trace=execve -p 1234

then in vim you can use any shell-invoking command like:

:!echo foo

and in the terminal running strace see something like:

[pid 1737876] execve("/usr/bin/zsh", ["zsh", "-c", "echo foo"], 0x561845a10070 /* 48 vars */) = 0

zsh -c is used because I have :set shell=zsh, but that's exactly what's being run. You can use this to see how vim processes characters like %, #, \, or |.

For example,

:!echo \%\|

results in

[pid 1747484] execve("/usr/bin/zsh", ["zsh", "-c", "echo %\\|"], 0x561845a10070 /* 48 vars */) = 0

strace might show much more output than you might be interested in. You can use grep to filter what you want, but note that the output is through stderr instead of stdout, so instead of a simple |, you should use something like |&. e.g.

sudo strace -fe trace=execve -p 1234 |& grep echo

This works for stuff beyond vim.

Answer 3

An easy check is :!foo that (probably) will print something like bash: line 1: foo: command not found. Also see :h job_start() (or :h jobstart() for Neovim) and so on.

To summarize:

• :! always uses &shell (as well as &shellcmdflag, &shellquote, &shellxqoute and so on);
• :h system() and :h systemlist() use &shell in Vim; in Neovim it depends on the first parameter (String = shell, List = direct);
• :h job_start() executes directly (Vim specific)
• :h jobstart() works like system(), i.e. String = shell, List = direct (Neovim specific)
• :h :term in Vim executes command directly (&shell is the default);
• :h :term in Neovim uses &shell (so :term sh results in two shells running one inside another).