Forem: woland

How to write vim9script or How to Compile and Run C code from Vim

woland — Wed, 30 Oct 2024 02:48:41 +0000

Using a simple vimscript, we can easily compile and run any C code without leaving Vim! We will use vim9script for this.

CompileAndRun Function

Functions in vim9script are defined with the def keyword. Since Vim uses an algol-like syntax, enddef will denote the end of the functions.

We will define several variables with the var keyword since vim9script doesn't use the let keyword.

vim9script

def CompileAndRun()
    var current_file = expand('%')
    var file_name = fnamemodify(current_file, ':t:r')

As with every vim9script, we start by telling vim that this is in fact vim9script!

Then we get the name of the current file using expand(), then using the fnamemodifty() and :t:t we will strip away the path and the extension, keeping only the basename.

:t: Takes only the "tail" (or basename) of the file path, removing the directories.
:r: Removes the extension from the filename.

Typically expand('%') returns filename.extension if you directly open a file with vim filename.extension but if the file was opened from a relative path, such as vim ~/some/path/filename.extension it would also return the path, so we have to clean it up.

We need another variable to store our compile command, for starters, a simple gcc compile command should do:

var compile_cmd = 'gcc ' .. current_file .. ' -o ' .. file_name

The .. is how we concatenate strings, in vim9script (it used to be one dot in legacy vimscript similar to PHP). You may have also noticed that we are using the extracted file name for our output binary.

After that we can simply compile and execute the output binary.

var compile_result = systemlist(compile_cmd)
execute 'terminal ./' .. file_name

So together:

def CompileAndRun()
    var current_file = expand('%')
    var file_name = fnamemodify(current_file, ':t:r')
    var compile_cmd = 'gcc ' .. current_file .. ' -o ' .. file_name 
    var compile_result = systemlist(compile_cmd)

    execute 'terminal ./' .. file_name
enddef

defcompile

The defcompile command in the end does exactly what it says, which is compiling our functions into bytecode.

Since vim9script functions are scoped differently than legacy vimscript, we need to define a command to access them.

command! CompileAndRun call CompileAndRun()

Now we can run :CompileAndRun.

Ok that's fine but what about errors? Warnings? WE NEED THOSE! So let's improve our script!

Let us add a condition that checks for v:shell_error, see :h v:shell_error.

    if v:shell_error != 0 || !empty(compile_result)
        botright new +setlocal\ buftype=nofile\ noswapfile\ bufhidden=wipe
        call setline(1, compile_result)
        return
    endif

Here is a summary, botright new creates a horizontal split, the +setlocal options ensure that it's a scratch buffer, systemlist() executes the binary while handling newlines properly, setline() puts the results at the first line of the split buffer.

Let's also add -Wall to our compile command and create an unused variable in our simple test C code.

var compile_cmd = 'gcc -Wall ' .. current_file .. ' -o ' .. file_name

Not bad ey? We can still make it better!

Another perk of using systemlist() is that it already captured 2>&1 aka stdout and stderr for us so we don't need to perform a redirection.

Can we add syntax highlighting to the warnings and errors? Yes! Just add set filetype=c before call setline().
Can we auto-close this split? Yes! But it needs a bit more code.

We will give a name to our split buffer, then using an augroup auto close it on leave.

if v:shell_error != 0 || !empty(compile_result)
    botright new +setlocal\ buftype=nofile\ noswapfile\ bufhidden=wipe
    file CompileErrors
    set ft=c
    call setline(1, compile_result)
    return
endif

augroup AutoCloseCompileErrors
    autocmd!
    autocmd! BufEnter * if bufexists('CompileErrors') && bufname('CompileErrors') != '' | silent! execute 'bdelete! CompileErrors' | endif
augroup END

This ensures that when we change focus from a buffer with the name CompileErrors, the buffer with be deleted and therefor the split will be closed.

However, there may be times when we'd want to keep the split open as we work, so we can create a boolean to set it to 1 or 0 at runtime.

g:close_err_split = true

And we'll modify the augroup and format it nicely:

augroup AutoCloseCompileErrors
    autocmd!
    autocmd BufEnter * if g:close_err_split &&
                \ bufexists('CompileErrors') &&
                \ bufname('CompileErrors') != ''
                \ | silent! bdelete! CompileErrors
                \ | endif
augroup END

We will be applying the same checks and niceties to the run command as well. So instead of simply running the binary, we can do the following:

g:close_run_split = true

if v:shell_error == 0 
    botright new +setlocal\ buftype=nofile\ noswapfile\ bufhidden=wipe
    resize -10
    file RunBin
    var results = systemlist('./' .. file_name)
    call setline(1, results )
endif

augroup AutoCloseRunBin
    autocmd!
    autocmd BufEnter * if g:close_run_split &&
                \ bufexists('RunBin') &&
                \ bufname('RunBin') != ''
                \ | silent! bdelete! RunBin
                \ | endif
augroup END

You may have noticed that this time we are also determining the size of the split.

Let us add the last touch, which is the ability to define the compile flags at runtime. For that we will have to add a condition to check for a g:custom_compile_flag and initiate it to be empty at first since vim9script is picky with empty variables.

if !exists('g:custom_compile_flag')
    g:custom_compile_flag = ''
endif

And of course, we have to also modify our compile_cmd:

var compile_cmd = 'gcc ' .. g:custom_compile_flag .. ' ' .. current_file .. ' -o ' .. file_name

Now we can change our compile flags at run time, just don't forget to add a space in the end!

Let's test:

As you can see, we can change our compile flags at runtime without any issues!

The whole script is as follows:

vim9script

def CompileAndRun()
    var current_file = expand('%')
    var file_name = fnamemodify(current_file, ':t:r')

    if !exists('g:custom_compile_flag')
        g:custom_compile_flag = ''
    endif

    var compile_cmd = 'gcc ' .. g:custom_compile_flag .. ' ' .. current_file .. ' -o ' .. file_name
    var compile_result = systemlist(compile_cmd)

    if v:shell_error != 0 || !empty(compile_result)   
        botright new +setlocal\ buftype=nofile\ noswapfile\ bufhidden=wipe
        file CompileErrors
        set ft=c
        call setline(1, compile_result)
        return
    endif

    if v:shell_error == 0 
        botright new +setlocal\ buftype=nofile\ noswapfile\ bufhidden=wipe
        resize -10
        file RunBin
        var results = systemlist('./' .. file_name)
        call setline(1, results )
    endif
enddef

g:close_err_split = true
g:close_run_split = true

augroup AutoCloseCompileErrors
    autocmd!
    autocmd BufEnter * if g:close_err_split &&
                \ bufexists('CompileErrors') &&
                \ bufname('CompileErrors') != ''
                \ | silent! bdelete! CompileErrors
                \ | endif
augroup END

augroup AutoCloseRunBin
    autocmd!
    autocmd BufEnter * if g:close_run_split &&
                \ bufexists('RunBin') &&
                \ bufname('RunBin') != ''
                \ | silent! bdelete! RunBin
                \ | endif
augroup END

command! CompileAndRun call CompileAndRun()
nnoremap <F8> :CompileAndRun<CR>

defcompile

We've also added the F8 keybinding to access our command more easily.

Note

Vim already has the compiler and make commands that you should add to your arsenal. This article only tries to teach some vim9script and some of the things that you can very easily achieve with it.

I hope that you enjoyed this article and if you did, leave a comment or a reaction.

Setting up Vim for PHP and laravel in 2024

woland — Mon, 17 Jun 2024 02:05:54 +0000

I am going to mostly document my own journy of setting up Vim (Not Neovim!) for PHP and laravel. Feel free to follow along.

We're going to use Vim+VimPlug+CoC.nvim, so we need to have nodejs and npm installed. It goes without saying that you should have Vim8+ as well. The current version of Vim as of this writing is Vim-9.1

So let's start from a clean ~/.vimrc

Lets place this block, that automatically installs VimPlug, on top of our `~/.vimrc`.

function! VimplugInstaller()
  let data_dir = has('nvim') ? stdpath('data') . '/site' : '~/.vim'
  if empty(glob(data_dir . '/autoload/plug.vim'))
    silent execute '!curl -fLo '.data_dir.'/autoload/plug.vim --create-dirs  https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim'
    autocmd VimEnter * PlugInstall --sync | source $MYVIMRC
  endif
endfunction

call VimplugInstaller()

Followed by several essential plugins:

call plug#begin()

Plug 'neoclide/coc.nvim', {'branch': 'release'}
Plug 'https://github.com/preservim/tagbar.git'
Plug 'vim-php/phpctags', {'for':'php'}
Plug 'honza/vim-snippets'
Plug 'SirVer/ultisnips'
Plug 'tpope/vim-commentary'
Plug 'sheerun/vim-polyglot'
Plug 'jwalton512/vim-blade'

call plug#end()

The most important one, is coc.nvim. The rest are for various enhancements, that we'll go over soon, but before we do, let's define some extensions for coc.nvim and configure the other plugins.

"===[Coc.nvim]==="
inoremap <silent><expr> <CR> coc#pum#visible() ? coc#_select_confirm() : "\<C-g>u\<CR>"
" use <tab> to trigger completion and navigate to the next complete item
function! CheckBackspace() abort
  let col = col('.') - 1
  return !col || getline('.')[col - 1]  =~# '\s'
endfunction

inoremap <silent><expr> <Tab>
      \ coc#pum#visible() ? coc#pum#next(1) :
      \ CheckBackspace() ? "\<Tab>" :
      \ coc#refresh()
inoremap <expr><s-tab> coc#pum#visible() ? coc#pum#prev(1) : "\<c-h>"

" Enhanced <CR> for pairs
inoremap <silent><expr> <CR> coc#pum#visible() ? coc#pum#confirm()
            \: "\<C-g>u\<CR>\<c-r>=coc#on_enter()\<CR>"

" Disable < expansion for pairs
autocmd FileType * let b:coc_pairs_disabled = ["<"]

"===[ Coc-Explorer ]==="
" set up coc-explorer to open in the current directory
let g:coc_explorer_global_mirror = 0
let g:coc_explorer_disable_default_keybindings = 1
let g:coc_explorer_global_root = 'current'
nnoremap <space>e <Cmd>CocCommand explorer<CR>

"===[ Coc Global Extensions ]==="
let g:coc_global_extensions = [
  \ 'coc-html',
  \ 'coc-css',
  \ 'coc-pairs',
  \ 'coc-emmet',
  \ 'coc-explorer',
  \ 'coc-phpactor',
  \ 'coc-blade'
\ ]

" GoTo code navigation
nmap <silent> gd <Plug>(coc-definition)
nmap <silent> gy <Plug>(coc-type-definition)
nmap <silent> gi <Plug>(coc-implementation)
nmap <silent> gr <Plug>(coc-references)

" Use `[g` and `]g` to navigate diagnostics
" Use `:CocDiagnostics` to get all diagnostics of current buffer in location list
nmap <silent> [g <Plug>(coc-diagnostic-prev)
nmap <silent> ]g <Plug>(coc-diagnostic-next)
"
" List code actions available for the current buffer
nmap <leader>ca  <Plug>(coc-codeaction)

nnoremap <silent> K :call ShowDocumentation()<CR>
function! ShowDocumentation()
  if CocAction('hasProvider', 'hover')
    call CocActionAsync('doHover')
  else
    call feedkeys('K', 'in')
  endif
endfunction

" Add `:Format` command to format current buffer
command! -nargs=0 Format :call CocActionAsync('format')
" Formatting selected code
vmap <leader>f  <Plug>(coc-format-selected)

" coc-pairs
" disable characters for a specified filetypes
autocmd FileType markdown let b:coc_pairs_disabled = ['txt']

The above code, configures tab completion, auto pairs, coc-explorer file explorer and other keybinding to get the most out of coc.nvim.
In the coc global extension section, we define extensions to be installed automatically. I have decided to use phpactor, you may change it for coc-intelephense.

Lets also configure the snippets:

We can manage our snippets with coc.nvim too, but I choose to use UltiSnips for that.

"===[ SNIPPETS ]==="
"Use Ctrl j key to trigger the snippets, default was TAB but that conflicts with
"The Completion trigger see :h keycodes to change this to sth else 
"Use Ctrl j and k to move visually within the snippet that was just triggered
"Ctrl l lists the available snippets
let g:UltiSnipsExpandTrigger='<C-j>'
let g:UltiSnipsListSnippets='<C-l>'
let g:UltiSnipsJumpForwardTrigger='<C-j>'
let g:UltiSnipsJumpBackwardTrigger='<C-k>'
let g:copypath_copy_to_unnamed_register = 1

Save and quit Vim and open it again and wait for the plugins and extensions to install.

If you get prompted by an error msg, just press enter and wait for the plugins and the extensions to install.

It's better to install the laravel extension manually:

:CocInstall @yaegassy/coc-laravel

Now lets configure the coc extensions.

Issue the :CocConfig command from Vim's command mode and paste the following, inside the file.

{
    "suggest.noselect": true,
    "explorer.icon.enableNerdfont": true,
    "explorer.file.reveal.auto": true
    "languageserver": {
        "phpactor": {
            "command": "phpactor",
            "args": ["language-server"],
            "trace.server": "verbose",
            "filetypes": ["php"]
        }
    }
}

If you choose to use a local installation of phpactor, you can just remove coc-phpactor with :CocUninstall coc-phpactor and modify the ~/.vim/coc-settings.json to include a path to the phpactor executable and remove the languageserver block entirely.

{
    "phpactor.enable": true,
    "phpactor.path": "/usr/bin/phpactor",
}

The keybindings:

The only keybindings that you should know, besides the usual Vim keybindings, are:

Key	Action
Tab	completion
gd	definition
gy	type definition
gi	implementation
gr	references
[g	diagnostics prev
]g	diagnostics next
ca	code actions
K	hover docs
f (in visual mode)	format code
Ctrl-j	Expand Snippet & Move to Next Placeholder
Ctrl+k	Move to Prev Placeholder
Ctrl-l	List Snippets
Space-e	Open Explorer

Now we should have an efficient and comfortable setup for working with PHP and laravel.

Lets setup several other things for convenience

Theme:

Add these plugins to the plugins list and install them with :PlugInstall after sourcing the ~/.vimrc.

Plug 'ryanoasis/vim-devicons'
Plug 'catppuccin/vim', { 'as': 'catppuccin' }

Setup Vim to use the popular catppuccin theme.

"===[ Theme ]==="
set background=dark
" Inspect $TERM instead of t_Co
if &term =~ '256color'
    " Enable true (24-bit) colors instead of (8-bit) 256 colors.
    if has('termguicolors')
        let &t_8f = "\<Esc>[38;2;%lu;%lu;%lum"
        let &t_8b = "\<Esc>[48;2;%lu;%lu;%lum"
        let &t_TI = ""
        let &t_TE = ""
        set termguicolors
        set mouse=a
        colorscheme catppuccin_mocha
    endif
    else
        colorscheme catppuccin_mocha
        let &t_TI = ""
        let &t_TE = ""
endif

if has('gui_running')
    set mouse=a
    set guicursor+=a:blinkon0
    set guifont=FiraCodeNerdFont\ 12
    colorscheme catppuccin_mocha
endif

"===[ Curosr Shape ]==="
let &t_SI = "\<Esc>[6 q"
let &t_SR = "\<Esc>[4 q"
let &t_EI = "\<Esc>[2 q"

The above block, will make vim use termgui colors (in a termgui capable terminal) and use different cursor shapes for different modes.
Make sure your $TERM variable reports xterm-256color.

In the screenshot below, you can see phpactor, coc-explorer and tagbar at work.
I've left an error in the syntax to show you what the inline diagnostics look like.

It would do you well to familiarize yourself with the coc.nvim documentation and commands.

For example, running :CocDiagnostics will open a drawer with all the errors found by coc.nvim.

Pressing enter on each item will jump you to the line containing the error.

I could not find a decent phpdoc plugin for Vim, but besides that, this setup is very effective.

You can find my full config on github, Woland's Vim and my personal ~/.vim here.

If you have any notes or questions, please leave a comment.

Where to go from here

Start using the setup and tweak it to your needs, little by little. This is not a drop and go config, it's just a kickstarter to put it plainly.

Some general notes:

Familiarize yourself with Vim's buffers.
NEVER :q Vim, unless you're done for the day
Learn about :vimgrep and :lvimgrep
Integrate fzf, ack, ag, rg into your workflow, (you need to quickly search large projects)

Possible Q&A

Can I use this with Nvim?
Yes, you just have to paste all the code into ~/.config/nvim/init.vim

Why not use Nvim with lspconfig and cmp etc ... ?
Because it takes way longer to configure and the results aren't better than what coc provides with so much ease.

Run any code from Vim

woland — Mon, 10 Jun 2024 22:13:08 +0000

Do you want to quickly run and test any code without leaving Vim and without even opening a :terminal?

There is a very simple way of achieving this. All we need is a runner function, a run command and a mapping to call it.

Here is an example:

function! CodeRunner()
    if &ft ==# 'python'
        execute 'RPy'
    endif
endfunction

and the run command:

command! RPy :!python3 %

and the mapping:

nnoremap <F12> :call CodeRunner()<CR>

I prefer to wrap the mapping and the run command inside an augroup:

augroup code_runner
    au!
    au FileType python command! RPy :!python3 %
    nnoremap <F12> :call CodeRunner()<CR>
augroup end

Place the above snippets in your .vimrc and source it. Now, every time you’re inside a python file, you can just press F12 to run the code and see its output.

You can add other languages to the function and to the augroup too:

"===[ Execute From Vim ]==="
function! CodeRunner()
   if &ft ==# 'python'
     execute 'RPy'
   elseif &ft ==# 'sh'
     execute 'RB'
   elseif &ft ==# 'javascript'
     execute 'RJs'
   elseif &ft ==# 'php'
     execute 'RPHP'
   elseif &ft ==# 'go'
     execute 'RGo'
   endif
endfunction

And the corresponding augroup:

augroup code_runner
    au!
    au FileType python command! RPy :!python3 %
    au FileType sh command! RB :!bash %
    au FileType javascript command! RJs :!node %
    au FileType go command! RGo :!go run %
    au FileType php command! RPHP :!php %
    nnoremap <F12> :call CodeRunner()<CR>
augroup end

With this, you can run bash, python, javascript, golang and php with the F12 key.

A better idea

While the above script works, it goes without saying that it's a mess, we can improve it by using a dictionary and checking the ft variable against it.

function! CodeRunner()
    silent !clear

    let file_commands = {
                \ 'python': 'python3',
                \ 'sh': 'bash',
                \ 'javascript': 'node',
                \ 'go': 'go run',
                \ 'php': 'php',
                \ 'perl': 'perl'
                \ }

    let ft = &filetype

    if has_key(file_commands, ft)
        let cmd = file_commands[ft]
        execute '!' . cmd . ' %'
    else
        echo "No run command defined for filetype: " . ft
    endif
endfunction

command! CodeRunner call CodeRunner()
nnoremap <F12> :CodeRunner<CR>

A similar method can be used for compiled languages, such as C.

Example:

function! CompileAndRun()
  let current_file = expand('%')
  let file_name = fnamemodify(current_file, ':t:r')
  let compile_cmd = 'gcc ' . current_file . ' -o ' . file_name . ' && ./' . file_name
  execute '!'.compile_cmd
endfunction

The function above, will compile the C code inside the current buffer using gcc, and then execute the binary output.

Naturally, we need a corresponding mapping:

nnoremap <F8> :call CompileAndRun()<CR>

More arguments can be added to the compile _cmd to serve your needs.

Update

You can improve the CodeRunner and CompileAndRun functions by converting them to vim9script.

vim9script

def CodeRunner()
    var file_commands = {
        'python': 'python3',
        'sh': 'bash',
        'javascript': 'node',
        'go': 'go run',
        'php': 'php',
        'perl': 'perl',
    }
    # filetype variable
    var ft = &filetype

    # check if ft is found in the dict
    if has_key(file_commands, ft)
        var cmd = file_commands[ft]
        silent !clear
        execute '!' .. cmd .. ' %' 
    else
        echo "No run command defined for filetype: " .. ft
    endif
enddef

# compile the functions 
defcompile

command! CodeRunner call CodeRunner()
nnoremap <F12> :CodeRunner<CR>

We can also improve our CompileAndRun function to display the compiler errors, which is something that we could've done in legacy vim9script as well, but oh well ...

# Compile and Run with Error Split
def CompileAndRun()
    var current_file = expand('%')
    var file_name = fnamemodify(current_file, ':t:r')
    var compile_cmd = 'gcc ' .. current_file .. ' -o ' .. file_name

    # Compile
    var compile_result = systemlist(compile_cmd)

    # If there are errors
    if v:shell_error != 0
        botright new +setlocal\ buftype=nofile\ bufhidden=wipe\ noswapfile
        file CompileErrors
        call setline(1, compile_result)
        return
    endif

    # Run binary
    execute 'terminal ./' .. file_name
enddef

defcompile

I think the comments are enough to let you know what is going on. It simply compiles and executes the binary while showing the results in a split, and if there are errors, it simply displays them in a split.

You can also set this up to automatically close the error split when you switch back to your code.

# Global variable to set if error split is closed automatically
g:compile_err_auto_close = 0

# Augroup to automatically close the error split
if g:compile_err_auto_close == 1
    augroup AutoCloseCompileErrors
        autocmd!
        autocmd! BufEnter * if bufname('CompileErrors') != '' | execute 'bdelete! CompileErrors' | endif
    augroup END
endif

Note

You only need to write defcompile once at the end of your script to compile all the functions in that file. So if you plan to put these functions in one vimscript file, you only need one defcompile entry for both of them.

Note Two

For a more complete and in depth script with an improved CompileAndRun function in Vim9Script, see my other article. How to write vim9script or How to Compile and Run C code from Vim

Forem: woland

How to write vim9script or How to Compile and Run C code from Vim

CompileAndRun Function

Note

Setting up Vim for PHP and laravel in 2024

Lets place this block, that automatically installs VimPlug, on top of our ~/.vimrc.

Followed by several essential plugins:

Lets also configure the snippets:

It's better to install the laravel extension manually:

Now lets configure the coc extensions.

The keybindings:

Lets setup several other things for convenience

Theme:

Setup Vim to use the popular catppuccin theme.

Where to go from here

Some general notes:

Possible Q&A

Run any code from Vim

A better idea

Update

Note

Note Two

Lets place this block, that automatically installs VimPlug, on top of our `~/.vimrc`.