Vi: Difference between revisions

Latest revision as of 10:00, 17 July 2023

This page is about the editor Vim itself. The other related pages are

Vimrc, dedicated to vim configuration settings and to the file ~/.vimrc.
Vim plugins, dedicated to Vim plugins.
Neovim, dedicated to NeoVim, a new port of Vim.

References

Things to look at

Use Ctrl-C or Alt-L as ESC replacement.
NeoVim fast setup:

LazyVim A Neovim setup powered by lazy.nvim.
NvChad
AstroNvim
LunarVim Another IDE-like setup for Neovim.

kitty Cross-platform, fast, feature-rich, GPU based terminal, with support for hyperlinks, image viewer.
tree-sitter An incremental parsing system for programming tools

Goes along with nvim-treesitter

ale — Check syntax in Vim asynchornously and fix files, with Language Server Protocol (LSP) support.
null-ls Use Neovim as a language server
nvim-lspconfig Quickstarts configs for Nvim LSP, suggested by Neovim project.
coc.nvim — Conquer of Completion (maybe older tech, but still maintained).
kickstart.nvim — A launch point for personal nvim configuration.
Mason A portable package manager (LSP, DAP...)
Comments on HN

External links

General

Official vim homepage
Vim Tips Wiki
Vim documentation: map
My links on vim on del.icio.us
List of all commands for each mode: :help index

Vi clones or inspired

Neovim
Kakoune, a vim-like but using noun-verb syntax.

General - Vim Help

Vim documentation: help
Built-in help:

" Get help on a command
:h map
" Get help on a mapping, NORMAL or INSERT mode
:h CTRL-R
:h i_CTRL-R

Other General

Vi Lovers home page
Why, oh WHY, do those #?@! nutheads use vi? — explains why vi is superior and defeats common misconceptions (with examples).
Vi would not be vi without a bit of fun...
vimsf discussion forum

Cheat sheets

Productivity & Setup Guides

Get the best Vim configuration

NEW — best of Vim
NEW — Level up your workflow with Vim and Tmux
NEW — How I'm able to take notes in mathematics lectures using LaTeX and Vim — Gilles Castel

Similar post on Quora, video on YouTube, snippets.

Tuned for Neovim

NEW — A guide to neovim

Guides & Cheat sheets

New To Vim
Quick Tips
Avoiding the ESC key
Vim map tutorial
Dr Chip's Vim Page — A tremendous amount of Vim treasures from an expert user
Efficient editing with vim (link dead, wayback machine, mirror)
C editing with VIM HOWTO
Using vim as an IDE all in one
Browsing programs with tags
Using Bash completion with ctags and Vim
Alternative tab navigation
Seven habits of effective text editing (from author of Vim)
Scripting the Vim editor, Part 1: Variables, values, and expressions (a great introduction to Vim scripting)
NEW — Turn Vim & Tmux into an IDE like environment

Uses ^h ^j ^k ^l to navigate between pane (also in Tmux apparently)
Tips: Use CapsLock as ESC, Copy Paste, Tab movements, Relative numbering
Plugins: NERDTree, Ctrl-P, Surround.vim, Comments, Snippets, Vim Wiki
ColbyCheeze dot files

NEW — Vim as XML Editor

Vim in Windows/Cygwin

Use cygwin shell
Running the Win32 version of Vim from Cygwin
viEmu — vim for Word, Outlook, Visual Studio...
cyg-wrapper.sh
FAQ / 33.6 What are the recommended settings for using Vim with cygwin?
Using Cygwin Bash as your Win32-Vim shell
A patch to use Win32 clipboard under Cygwin ([1], [2])

Tips

Use Ctrl-O instead of Esc in insert mode mappings
How do I indent multiple lines quickly in vi?
Replace a word with yanked text
Here we learn that Deleting, Changing and Yanking text copies the affected text to unnamed buffer ("").
But Yanking text also copies the text to buffer 0 ("0)
Search and replace the word under the cursor
Find in files within Vim
About commands :grep, :lgrep, :vimgrep, :lvimgrep
Power of g
Examples on how to use the command :rg/pattern/cmd
Keystroke Saving Substituting and Searching
Quickly adding and deleting empty lines
Very basic session persistence
Using mksession! and :au VimLeave...
Automatically fitting a quickfix window height
Highlight unwanted spaces
Using Vim's tabs like buffers

:set hidden to have vim behave like any other multi-file editors.

Use :bn, :bp, :b #, :b name, ^6 and #^6 to switch between buffers. ^6 are very useful to switch to previously used buffer (or #^6 to switch to buffer #).

Use :ls to list buffers.

Vimrc examples

https://github.com/mitechie/pyvim (author of the screencast on LustyJuggler)
https://github.com/colbycheeze/dotfiles

Use vim-plug to manage plugins.

Vim help

Help on mappings

For mapping like <C-U> (ie. <Ctrl-U>): :h CTRL-U
For mapping like <C-G>u: :h CTRL-G_u (not the same as :h CTRL-G_U).
For mapping like <C-G>u in insert mode: :h i_CTRL-G_u

Related projects

Universal ctags

A maintained version of exuberant ctags.

First uninstall exuberant-ctags if installed:

sudo apt-get remove exuberant-ctags

To build (see docs/autotools.rst):

git clone https://github.com/universal-ctags/ctags.git
cd ctags
./autogen.sh
./configure
make
sudo make install

Install

Building from Sources

See

Build Vim on Cygwin
Building Gvim from source (linux)

Invocation

vi -p file1.txt file2.txt                  # Open each file in a different tab
vi -t tagname                              # Open file and move cursor at specified tag (requires ctags)
view file.txt                              # View file in vim, with syntax highlighting... (read-only)
vimdiff file1.txt file2.txt                # View differences in vim

The following is a description of the start up sequence as I understood by experience. It's certainly far from complete. For more information:

:version
:echo $HOME
:echo $VIM
:set runtimepath?
:help vimrc
:help gvimrc
:help runtimepath

First, load the system config files:

File	description	OS	Location
vimrc	System config file for vim and gvim	Unix & Win	`$VIM/vimrc`
gvimrc	System config file for gvim only	Unix & Win	`$VIM/gvimrc`

Second, load the user config files:

File	description	OS	Location
vimrc	User config file for vim and gvim	Unix	`$HOME/.vimrc`
vimrc	User config file for vim and gvim	Win	`$HOME/_vimrc`
gvimrc	User config file for gvim only	Unix	`$HOME/.vimrc`
gvimrc	User config file for gvim only	Win	`$HOME/_vimrc`

Search for runtime files in path 'runtimepath'. Basically vim looks for directories in that path for further runtime files to execute (see :help runtimepath for more information)

Using vimdiff

Invoke vimdiff with

vimdiff file1.txt file2.txt

One can tell vim to ignore case or whitespaces with:

" Ignore case differences
:set diffopt+=icase
" Ignore white space differences
:set diffopt+=iwhite
" Tell vim to redo comparison (in case file was edited)
:diffupdate

Plugins

See Vim plugins.

Vim on Windows

Tab Edit with &Vim — The following registry setting add a context menu item in explorer to open a file in a new tab in a running instance of gvim (see [3]):

REGEDIT4
[HKEY_CLASSES_ROOT\*\Shell\Tab Edit with &Vim\command]
@="\"C:\\Program Files\\vim\\vim71\\gvim.exe\" -p --remote-tab-silent \"%1\" \"%*\""

Best solution however is to use the gvim explorer menu extension, which offers much more functionality (see NXL67170).

Share config with Cygwin

To have win32 gvim and cygwin vim, use the same config files. Simply define the env. var HOME to point to user home in cygwin:

HOME=c:\cygwin\home\username

Create the file C:\Program Files\Vim\vimrc (system vimrc file for windows)

set runtimepath-=~/vimfiles
let tmp=&runtimepath
let &runtimepath="~/.vim,".tmp

Win32 gvim will read the standard configuration files .vimrc and .gvimrc (although this is not reported by :version). It will also fetch the plugins from cygwin home directory.

Detect windows in vimrc script

Use has('win32') or alike:

if has('win32')
    echo "Windows (32 or 64 bits)"
endif
if has('win32unix')
    echo "Cygwin"
endif
if has('unix')
    echo "linux"
endif
if has('macunix')
    echo "Mac"
endif

Enable Ruby support

There is a bug in Vim7.3_46 that crashes vim when ruby is loaded. This is fixed in a later release [1]. Install:

Latest Vim from Cream (currently Vim 7.3.260)
This version of Vim requires Ruby 1.8.x (and not Ruby 1.9.1 as indicated in :help ruby).
Download ruby-1.8.7-p330-i386-mswin32.zip from here, and install it in C:\RUBY.
Add C:\RUBY\bin to system path (before cygwin!)

Save .vimrc in utf-8 format *with* BOM

Vim Windows will default to Iso8859 encoding on windows. By adding the BOM to .vimrc file, it'll ensure that both Vim Linux and Vim Windows will use the same encoding to read the configuration file (relevant in case you have special character in .vimrc)

Use Caps Lock as Escape key

Import the following in the registry then logout/logon:

REGEDIT4
[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Keyboard Layout]
"Scancode Map"=hex:00,00,00,00,00,00,00,00,03,00,00,00,3a,00,46,00,01,00,3a,00,00,00,00,00

To restore old behavior:

REGEDIT4
[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Keyboard Layout]
"Scancode Map"=hex:00,00,00,00,00,00,00,00,03,00,00,00,3a,00,46,00,01,00,3a,00,00,00,00,00

Check also potential goodies Vi#Vim_in_Windows.2FCygwin above.

Configuration

Color schemes

Solarized (truecolor) — Git plugin, my fork.

My current favorite scheme, cheerful colors. But I would like to increase the contrast for the main text.

Gruvbox (truecolor)

A truecolor color scheme.

Tabs and indent

"#### Indentation ########################################
set tabstop=4 softtabstop=4 shiftwidth=4 noexpandtab
set autoindent                  " Indent is based on the previous line
" set smartindent               " Same as above but also recognize some C syntax
" set cindent                   " Even clever C indent mode
" set cinkeys=0{,0},:,0#,!,!^F  " For cindent - specifies which keys trigger reindenting

Or shorter:

set ts=4 sts=4 sw=4 noet

Cursor shape and mode

By default, the cursor shape depends on the UI:

In TUI, cursor is always has a block shape.
In GUI (gvim), cursor is either a blinking block (normal mode), or a blinking caret (insert mode).

In TUI, we can configure the cursor for terminals that support it:

Under tmux, using escape sequences [4]. Add to .vimrc:

" set the cursor to a vertical line in insert mode and a solid block
" in command mode
let &t_SI = "\<Esc>Ptmux;\<Esc>\<Esc>]50;CursorShape=1\x7\<Esc>\\"
let &t_EI = "\<Esc>Ptmux;\<Esc>\<Esc>]50;CursorShape=0\x7\<Esc>\\"
" upon hitting escape to change modes,  send successive move-left and move-right
" commands to immediately redraw the cursor
inoremap <special> <Esc> <Esc>hl

" don't blink the cursor
set guicursor+=i:blinkwait0

Finally, in tmux.conf:

# don't wait for an escape sequence after hitting
# Esc. fixes insert mode exit lag in vim
set -sg escape-time 0

Managing Options

See :help options for more details

"Show all options that differ from default
:set
"Show value of {option}
:set {option}?
"Set {option} to value
:set {option}={value}
"Add value to {option}
:set {option}+={value}

Scripting

Variables, environment variables and options

Some basic stuff on Vim scripts:

" Use LET for VARIABLES
let myvar="Hello"
echo myvar
let myvar=call func(param1,param2)


" Use SET for OPTIONS
set runtimepath=~/.vim         " SET option"
set runtimepath?               " GET option"


" We can use LET with &{OPTIONS}
let myvar='batch'
let &filetype=myvar            " &{option} returns option value in an expression"
echo &filetype
if &filetype == 'java'
    ...
endif


" But these does not give the same:
set runtimepath?               " No expansion within runtimepath (eg. replace ~ with /home/...)"
echo &runtimepath              " Expansion occurs with runtimepath"


" Another example, use variable to prepend a path to runtimepath:
set runtimepath-=~/vimfiles
let tmp=&runtimepath
let &runtimepath="~/.vim,".tmp

Use let to edit environment variables:

let $MAKEFLAGS="-j1"            " Set env. var MAKEFLAGS - force sequential build

Expressions

See :h expression-syntax for more.

|expr1| expr2 ? expr1 : expr1	if-then-else

|expr2|	expr3 || expr3 ..	logical OR

|expr3|	expr4 && expr4 ..	logical AND

|expr4|	expr5 == expr5		equal
	expr5 != expr5		not equal
	expr5 >	 expr5		greater than
	expr5 >= expr5		greater than or equal
	expr5 <	 expr5		smaller than
	expr5 <= expr5		smaller than or equal
	expr5 =~ expr5		regexp matches
	expr5 !~ expr5		regexp doesn't match

	expr5 ==? expr5		equal, ignoring case
	expr5 ==# expr5		equal, match case
	etc.			As above, append ? for ignoring case, # for
				matching case

	expr5 is expr5		same |List| instance
	expr5 isnot expr5	different |List| instance

|expr5|	expr6 +	 expr6 ..	number addition or list concatenation
	expr6 -	 expr6 ..	number subtraction
	expr6 .	 expr6 ..	string concatenation

|expr6|	expr7 *	 expr7 ..	number multiplication
	expr7 /	 expr7 ..	number division
	expr7 %	 expr7 ..	number modulo

|expr7|	! expr7			logical NOT
	- expr7			unary minus
	+ expr7			unary plus

|expr8|	expr8[expr1]		byte of a String or item of a |List|
	expr8[expr1 : expr1]	substring of a String or sublist of a |List|
	expr8.name		entry in a |Dictionary|
	expr8(expr1, ...)	function call with |Funcref| variable

|expr9| number			number constant
	"string"		string constant, backslash is special
	'string'		string constant, ' is doubled
	[expr1, ...]		|List|
	{expr1: expr1, ...}	|Dictionary|
	&option			option value
	(expr1)			nested expression
	variable		internal variable
	va{ria}ble		internal variable with curly braces
	$VAR			environment variable
	@r			contents of register 'r'
	function(expr1, ...)	function call
	func{ti}on(expr1, ...)	function call with curly braces

Process control

if filereadable("foo.cfg")      " Boolean"
   " ...
endif
while lnum <= line("$")         " Number - other tests are =, !=, <=, >="
    call FixLine(lnum)
    let lnum = lnum + 1
endwhile
if $ENV_VAR != ""               " String"
    echo $ENV_VAR
endif

" FOR with LISTS
for item in ["foo", "bar"]
    echo item
    unlet item                  " E706 without this"
endfor
for item in ["foo", ["bar"]]
    echo item
    unlet item                  " E706 without this because different item types
endfor
for [lnum, col] in [[1, 3], [2, 5], [3, 8]]
    echo getline(lnum)[col]
endfor

Handy functions

(see :h functions for complete list)

glob("/foo/bar")                " String, extension file wildcard (here as file existence test)"
filereadable("foo.cfg")         "  Number, TRUE if file readable"

Testing version, options and features

Some examples for testing Vim version, and option/feature availability [5]:

if v:version < 703          " Exit if Vim version 7.3 or less
    finish
endif
" Plugin goes here.

" Avoid installing twice or when in unsupported Vim version.
if exists('g:loaded_pluginname') || (v:version < 700)
    finish
endif
let g:loaded_pluginname = 1

To test whether an option/feature is available

exists('+relativenumber')     " Is option relativenumber available?
has('python')                 " Is feature python supported?

How-to

Test for quickfix buffer

&filetype == 'qf'               " Test filetype
&buftype ==# 'quickfix'         " Test buftype

Frequent caveats

Don't confuse variables and options.

Variables are initialized with let, options with set. Options can be read/written like a variable with prefix &, like &filetype.

Don't confuse functions (like max, strlen), with editor commands (like let, set, call).

Functions can be called directly in expression, but must be called with command call where commands are expected.

add(list,10)                    " WRONG! add is not an editor command
list2=add(list,10)              " CORRECT
call add(list,10)               " CORRECT

Give regular expression patterns in single-quotes!

echo match("binary(blob)","b\|(",0)   " WRONG!
echo match("binary(blob)",'b\|(',0)   " CORRECT

Mappings

Mouse mappings requires :set mouse=a.

View mappings

List mappings:

:map
:map!

List mappings, with origin:

:verbose map
:verbose map!

Define new mapping

Note that not all combinations are possible (see [6] and help :keycodes)
- S-b and S-B are the same
- C-b and C-b (both mean 0x02)
- A-b and A-B are different, but are represented by vim by setting the high bit (0x80), so A-b is same as 'â', and A-B is same as 'Â'
Note that GUI Vim some Alt key shortcuts select the menu. To disable that:

set guioptions-=m

Cheatsheets

Custom mappings are underlined.

Custom Cheatsheets

Mappings

Window management
`^W`_ `^W`\| `^W`= `^W`h `^W`l `^W`j `^W`k `^W`p `^W`o `^W`t	Max. h/w current window or tile Move to left, right window Move to down, up window Move to previous window Show current window only Promote window to tab

Mouse
`MouseL` g`MouseR` `^MouseR`	Jump to tag Return from tag

Command-line Mode (`:`)
`^U` `^R` `^R=` `^W`	Remove auto-range (`:help omap-info`) Insert register / object (`:help c_CTRL-R`) Insert expression (eg.`&gfn`) Delete previous word

Insert Mode
`^Space` `^O`	Same as `Esc`, but easier (see [7]) Execute one command, back to insert mode

Normal Mode
n`^O` n`^I` `:ju[mps]` `^R` `&` `:%&`	Go to n older pos. in jump list Go to n newer pos. in jump list Print jump list Redo Repeat last substitution Repeat for all lines (add `c` for confirmation)

Registers
`"ay`	YANK to / paste frmo register a.
`"Ay`	APPEND to register a.

Miscellaneous
`^^` or `^6` (azerty)	Edit alternate buffer (#)

Operators & motions

Operators in Vim acts

on the current selection (visual mode like v, V or ^v) when there is such a selection,
or must be followed by a motion indicating which part of the text must be modified.

Operators

c d y ~ g~ gu gU ! = gq g? > < zf g@	change delete yank into register (does not change the text) swap case (only if 'tildeop' is set) swap case make lowercase make uppercase filter through an external program filter through 'equalprg' or C-indenting if empty text formatting ROT13 encoding shift right shift left define a fold call function set with the 'operatorfunc' option

The motion is either one of the motion key (like >% for shift right until match) or an operator motion (like diB for delete inner {} block). See :help operator.

Frequently-used operator motion

`iw` `iW` `is` `ip`	inner word inner WORD inner sentence inner paragraph	`aw` `aW` `as` `ap`	a word a WORD a sentence a paragraph	`i[` `ib` `i(` `i<` `it` `iB` `i{`	inner [] block inner () block inner <> block inner tag block inner {} block	`a[` `ab` `a(` `a<` `at` `aB` `a{`	a [] block a () block a <> block a tag block a {} block	`i"` `i'` i`	inner "" string inner '' string inner `` string	`a"` `a'` a`	a "" string a '' string a `` string

Commands

" Search & replace - current line
:s/search/replace/g
" Search & replace - global scope
:%s/search/replace/g
" Set Vim option (here textwidth)
:set {option}=70
" Show value of {option}
:echo &{option}
:set {option}?
" Search / replace in all opened buffers
:bufdo %s/pattern/substitution/ge | update
" Replace current line with register content
VP

General tips

Practical Vim — Part I: Modes

Tip 4: Act, Repeat, Reverse —

Make a change	{edit}	`.`	`u`
Scan line for next character	`f{char}` / `t{char}`	`;`	`,`
Scan line for previous character	`F{char}` / `T{char}`	`;`	`,`
Scan document for next match	/pattern`CR`	`n`	`N`
Scan document for previous match	/pattern`CR`	`n`	`N`
Perform substitution	:s/target/replacement	`&`	`u`
Execute a sequence of changes	`qx {changes} q`	`@x` `éx`	`u`

Tip 6: Meet the Dot Formula —One keystroke to move, one keystroke to execute (like A.ESC then j.j.j., f+s_+_ then ;.;.;., *cwcopyESC then n.n.n.)
Tip 9: Compose Repeatable Changes — e.g. favor daw instead of dbx or bdw to delete a word, because the former is a single operation, and hence invests the most power into the dot command.
Tip 13: Make Corrections Instantly from Insert Mode — e.g. use ^h for backspace, ^w for delete word, ^u for delete line.
Tip 14: Go Back to Normal Mode — use ^[ for Switch to Normal mode, and ^o for Insert Normal mode (e.g. ^ozz).
Tip 15: Paste from a Register Without Leaving Insert Mode

use ^r for putting character-wise register, and ^r^o for inserting characters litteraly and without auto-indent
remap CAPS LOCK (capslock) to something else at system level, either ESC (escape) or CTRL (see Tips section).

Tip 16: Do Back-of-the-Envelope Calculations in Place — Example a ^r= 6*35 CR
Tip 17: Insert Unusual Characters by Character Code — ^v123 inserts by decimal code, ^vu1234 inserts by hexadecimal code, ^v non-digit inserts literally, ga returns character code.
Tip 18: Insert Unusual Characters by Digraph — ^k char1 char2 inserts digraph. See :h digraphs-default (convention), :h digraphs (all digraphs), :h digraph-table (more usable list). There's also plugin betterdigraphs.vim from Damian Conway.
Tip 19: Overwrite Existing Text with Replace Mode — r, R to replace, Insert to switch mode, gr,gR to replace visually.
Tip 21: Define a Visual Selection — gv reselect the last visual selection, o go to other end of highlighted text.
Tip 27: Command-Line Mode — ^v or ^k to insert special character, ^r{register} to insert content of any register.
Tip 28: Execute a Command on One or More Consecutive Lines — Example of ranges :1p, :$p, :2,5p, :.,$p, :%p, :'<,'>p, /<html>/,/<\/html>/p, /<html>/+1,/<\/html>/-1p, :.,.+3p (there is also 0 for virtual line before first line).
Tip 29: Duplicate or Move Lines Using ':t' and ':m' Commands — :[range]copy {address} or :[range]t {address} for copy, :[range]move {address} or :[range]m {address} for move.
Tip 30: Run Normal Mode Commands Accross a Range — Use :[range]normal {command} or :[range]norm {command}. Eg. :%norm ., :%norm A;, :%norm i//.
Tip 31: Repeat the Last Ex Command — Use @: and @@ afterwards (last command always stored in : register).
Tip 32: Tab-Complete Your Ex Commands — Use ^d to view auto-complete list, Tab and S-Tab to cycle through it.
Tip 33: Insert the Current Word at the Command Prompt — Use ^r^w to insert current word, ^r^a for current WORD.
Tip 34: Recall Commands from History — Use Up/Down or or ^p/^n to recall command with filtering. Use :q for Command-Line Window (Enter to execute, :q to leave). Use ^f to switch to Command-line window, even while typing a command. Use following mapping to have filtering enabled for ^p/^n:

cnoremap <C-p> <Up>
cnoremap <C-n> <Down>

Tip 35: Run Commands in the Shell — Use % as shorthand for current file name, like :!ruby % (see :h cmdline-special)
- :shell runs a shell (in a terminal better use ^z to suspend vim),
- :!{cmd} executes a command with the shell,
- :read !{cmd} inserts command output at the cursor,
- :[range]write !{cmd} executes command with selected text as input,
- :[range]!{filter} filters selected text through command.

Practical Vim — Part II: Files

Tip 36: Track Open Files with the Buffer List — :ls to list buffers; :buffer N or :buffer {bufname} to jump directly; :bprevious, :bnext, :bfirst and :blast to navigate through buffers; :bdelete to delete buffers; and :bufdo to execute command on all buffers. :write, :update and :saveas to write buffer to disk.

Efficient Editing

Dot command — See [8] for example.
Use * to search word under cursor (and # backward) &mdash see also [9] for example.
Substitute current line — Use S ( or cc) to replace the current line, while keeping current indentation (instead of ddO to delete current line and open new one)

" F3 (an improved UltraEdit F3 ;-) ) search for next occurrence of replaced word (actually register -) - handy for refactorizing code
" Also mapped to ù (AZERTY power!)
nnoremap <F3> /\<<C-R>-\><CR>
nnoremap ù /\<<C-R>-\><CR>

Using this mapping, one can:

Rename a variable with ciw for instance, and type the new variable name (use ^R- to start from old name)
Look for next occurent of the replaced variable with F3 (or ù)
Repeat replacement with . (dot key)
Repeat from step 2 (or use n), or N for previous occurrence.

This tip works better than using range:s/pattern, because you don't have to type the name of replaced variable, nor use the word delimiter \<...\>, and you don't have to specify a range in advance.

Quick buffer edit — Use :b {bufname} to quickly jumped to buffer referenced by its number (see :ls) or by its name. Buffer name can be incomplete as long as it is unique (this is very handy!!!).
use ( and ) to move between sentences, ]p paste indented, `. move to last edit (source Efficient editing with vim)
Smart ranges and clipboards — (source [10])

if (!entry.used && |equivalent(entry.key(), qk.key) && (curcontext & entry.contexts))

Starting from cursor position above , type c% and equivESC, and then Obool equiv = C-R";ESC to get the result below.

bool equiv = equivalent(entry.key(), qk.key);
if (!entry.used && equiv && (curcontext & entry.contexts))

Syntax folding — Enable automatic folding for javascrip, PHP, XML, ... [11]

.vimrc

set foldmethod=syntax
set foldlevelstart=1

let javaScript_fold=1         " JavaScript
let perl_fold=1               " Perl
let php_folding=1             " PHP
let r_syntax_folding=1        " R
let ruby_fold=1               " Ruby
let sh_fold_enabled=1         " sh
let vimsyn_folding='af'       " Vim script
let xml_syntax_folding=1      " XML

# https://stackoverflow.com/questions/32154285/folding-expanding-and-colapsing-xml-tags-in-vim-xml-parsing
au FileType xml setlocal foldmethod=syntax
au FileType xslt setlocal foldmethod=syntax

Use Caps Lock as another Escape (ESC) key.

Linux

X#Configuring_Layout_Options

gsettings get org.gnome.desktop.input-sources xkb-options
gsettings set org.gnome.desktop.input-sources xkb-options "@as ['caps:escape']"

On Windows, see Map caps lock to escape in Windows. Import the registry file (Win7/Win8):

Windows Registry Editor Version 5.00

[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Keyboard Layout]
"Scancode Map"=hex:00,00,00,00,00,00,00,00,03,00,00,00,3a,00,46,00,01,00,3a,00,00,00,00,00

Modeline

Use modeline to embed vim format settings in the document itself. This requires the following line in ~/.vimrc:

set modeline

The format of the modeline is (see help modeline for more variants): [text] vim:{options} [text] vim: set {options}:

Now you can for instance for automatic word wrapping in a text document by adding the following line to the document (for instance as the last line or within a comment block):

/* vim: set ai fo=tcroq tw=105: */

Alternatively, use the following to disable automatic line break, but still wrap words at word boundaries:

/* vim: set ai fo=tcroq tw=0 wrap linebreak nolist: */

Add spell to enable background spell checker (e.g. LaTeX document):

/* vim: set ai fo=tcroq tw=105 spell: */
/* vim: set ai fo=tcroq tw=0 wrap linebreak nolist spell: */

Markdown

Use the following line [12]:

[//]: # ( vim: set tw=105: )

Miscellaneous

Inserting only a single character (http://vim.wikia.com/wiki/Insert_a_single_character):

:nnoremap <space> :exec "normal i".nr2char(getchar())."\e"<CR>

Macro

qq to start recording a macro q. End macro with q again.
@q to replay macro, followed by . to replay it again.

Visual Block

Ctrl-v to start VISUAL BLOCK mode.
Shift-I to insert some text at the start of each line of selected block.

wrap-around

Set option whichwrap or ww that allows specified keys that move the cursor left/right to move to the previous/next line when the cursor is on the first/last character in the line.
In Vim, <space> and <backspace> are set to wrap-around by default.

Read-only viewer (with syntax highlighting):

$ vi -R sensitive_file
$ view sensitive_file

Retab

:retab

[13]

convert tabs into space

:set expandtab
:retab

View differences in vim

vimdiff file1.txt file2.txt

Interaction with X Clipboard

vim

clipboard

vim --version

+clipboard

+

vim

autoindentation

paste

Ubuntu

gvim

vim-gnome

vim-gtk

+clipboard

vim

set mouse=a

shift-mouse

mouse-using

:set paste            " Enable paste mode, i.e. disable autoindent, mapping... "
:set nopaste          " Disable paste mode (back to normal...) "

set incsearch, moves cursor as search pattern is typed. Ctrl-L to type letter under cursor, Ctrl-R Ctrl-W to type current word.
References:

http://vim.wikia.com/wiki/Best_Vim_Tips

type :help ctrl<C-D>, to get a list of all ctrl sequence. Type <C-D> in command line for auto-completion.
Support 256 colors in gnome-terminal: add set t_Co=256 in ~/.vimrc ([14])
Use :make and :grep instead of :!make or :!grep. Then use :cwin or :copen to view the results of either make or grep in a coloured list (from [15]).
(from [16]), The :g command is useful to apply a command to all lines matching a search.

" delete all lines matching pattern
:g/pattern/d
" --> example: delete empty lines
:g/^$/d
" --> example: delete lines with only whitespaces
:g/^\s*$/d
" delete all lines *NOT* matching pattern (:v same as :g!)
:g!/pattern/d
:v/pattern/d

vim-syntax-extra — C syntax extension, to also highlight C delimiters. Copy as file ~/.vim/after/syntax/c.vim (and ~/.vim/after/syntax/cpp.vim).

foldmethod=syntax

" OBSOLETE - THESE BREAK FOLDMETHOD=SYNTAX
syn match cDelimiter "[&\.!^,;:<>=|+%*-]"
syn match cParenDelimiter "[][(){}]"
hi def link cDelimiter Delimiter
hi def link cParenDelimiter Delimiter

Replace a word with yanked text (see tip [17])

yiw         " Yank word under cursor "
...         " Move to next word "
viwp        " Replace current word with yanked text. "
...
viwp
...

Quickly switch between opened buffers. The commands :b and :sb accepts partial buffer name when specifying which buffer to edit:

:ls                    " List buffer list, say you have a file verylongfilename_spec.c and anotherverylong_code.c"
:b spec                " Will switch to buffer verylongfilename_spec.c"
:sb code               " Will split the window and switch to buffer anotherverylong_code.c"

Various command to interact with the shell:

`:!{cmd}`	Execute {cmd} with the shell.
`:!!`	Repeat last ":!{cmd}".
`:[range]r[ead] !{cmd}`	Execute {cmd} and insert its standard output below the cursor or the specified line.
`:[range]w[rite] [++opt] !{cmd}`	Execute {cmd} with [range] lines as standard input.

Save a file you edited without the needed permissions (source [18])

:w !sudo tee %

Delete all trailing spaces ([19]):

:%s/\s\+$//                     " Remove all trailing spaces
:%s/\s\+$                       " We can omit substitution text if blank

Add this to .vimrc to have vim remove automatically trailing spaces before saving

autocmd BufWritePre * :%s/\s\+$//e

More elaborate version:

" Trim trailing spaces on save
if !exists("autocmd_BufWritePre_trimspace_tab")
    let autocmd_BufWritePre_trimspace_tab = 1
    autocmd FileType c,cpp,java,php,vim autocmd BufWritePre <buffer> :call setline(1,map(getline(1,"$"),'substitute(v:val,"\\s\\+$","","")'))
    " autocmd BufWritePre * :set expandtab<CR>:retab
endif

Or better yet, create a custom mapping [20]:

" F10 - Remove all trailing whitespace
nnoremap <F10> :let _s=@/<Bar>:%s/\s\+$//e<Bar>:let @/=_s<Bar><CR>

Promote window to tab (see [21])

:noremap <C-W>t :tabedit <C-R>%<CR>gT<C-W>qgt

Find in files within Vim (commands :grep, :lgrep, :vimgrep, :lvimgrep)

" We must embed :grep in :execute or otherwise vim will append /dev/null
" to :cw command and will complain of E488: trailing characters
command! GREP :execute "grep -R <cword> ./src"|:cw

Use :E[xplore] for explore directory of current file (from netrw)
Formatting code with column shell filter. Say you have a code like the one on the left. To align this text, select the 3 lines, then !column -t. This will give:

int myint = 1;
double a = 2.0;
float verylongf = 1234.50;

→

int     myint      =  1;
double  a          =  2.0;
float   verylongf  =  1234.50;

Only english dictionary is available by default. But Vim will automatically download and install the french dictionary with

set spelllang=fr

Use set fileencoding=utf-8 to convert a file to unicode UTF-8 format. Vim can also add the BOM (Byte Order Mark) with setlocal bomb

" Convert into utf-8
set fileencoding=utf-8
" Add the BOM
setlocal bomb
" Remove the BOM
setlocal nobomb

Justify text. For instance justifying left-right, with 74-char line (require package par:

!par -jw74

Copy current buffer filename into clipboard:

:let @+=expand("%")<CR>        " Copy basename
:let @+=expand("%:p")<CR>      " Copy fullpath

Create a new file / directory — Easy with plugin NERDTree. Open NERDTree, then navigate to folder where to create the new file, then press ma. This will create a new file / directory in given node.

Spell checker

French

Vim will automatically download and install FR dictionary with

:set spelllang=fr

To install manually, download FR dictionaries with

cd ~/.vim/spell/
wget http://ftp.vim.org/vim/runtime/spell/fr.latin1.spl
wget http://ftp.vim.org/vim/runtime/spell/fr.latin1.sug
wget http://ftp.vim.org/vim/runtime/spell/fr.utf-8.spl
wget http://ftp.vim.org/vim/runtime/spell/fr.utf-8.sug

Alternatively, copy them into /usr/share/vim/vim7X/spell/ to have them available globally.

Command-line mode Tips

Ex special characters — These are special character that can be used in executed command line (:! ...) or when ex is expecting a filename (see also :help <cword>):

<cword>         replaced with word under cursor
<CWORD>         replaced with WORD under cursor
<cfile>         replaced with pathname under cursor
...

Insert register / object <C-R> — these can be used to insert some register content or text from context (see also :help c_CTRL-R):

<C-R>*          insert X11 clipboard content
<C-R>+          insert clipboard content
<C-R>=          expression register. You are prompted to enter an expression
<C-R><C-W>      insert word under cursor
<C-R><C-A>      insert WORD under cursor

Example of expressions:

nmap <C-@><C-@> :cs find s <C-R>=expand("<cword>")<CR><CR>

Insert an environment variable $VAR in command map — Use <C-R>=$VAR<CR> to have a command map use the value of an environment variable

nmap <silent> <F12> :wa<CR>:b <C-R>=$VPMAINDOC<CR><CR>\ll

New user-defined command in lowercase —

newcommand

abbreviation

[22]

cboreabbrev ag <c-r>=(getcmdtype()=':' && getcmdpos()==1 ? 'Ag' : 'ag')<CR>

Clipboard support

On Linux, install gvim to get full clipboard support
- On Terminator, use also shortcuts ^S-c and ^S-V to copy & paste.
On Cygwin, install gvim and a X server.
- vim will not have clipboard support. But similar result can be obtained by using :set paste, then i, followed by S-Insert (under mintty)
- gvim under Cygwin/X will have clipboard support.
- There is also some plugin (e.g. [23])
Alternatively, install Win32 gvim (but this versions is not correctly integrated in cygwin, or requires use of wrapper)

Whitespaces

A nice tip about highlighting unwanted spaces
Use set list and set listchars to show trailing space, tags, extending spaces as another character...
Some examples:

:set list listchars=tab:>-,trail:.,extends:>,precedes:<
" Enter the middle-dot by pressing Ctrl-k then .M
:set list listchars=tab:\|_,trail:·
" Enter the right-angle-quote by pressing Ctrl-k then >>
:set list listchars=tab:»·,trail:·
" Enter the Pilcrow mark by pressing Ctrl-k then PI
:set list listchars=tab:>-,eol:¶
" The command :dig displays other digraphs you can use.

To hide tabs even when using listchars:

:set list listchars=tab:\ \ ,trail:·,extends:>,precedes:<

This is also subject to highlighting ("NonText" is used for "eol", "extends" and "precedes" / "SpecialKey" for "nbsp", "tab" and "trail")

Advanced source highlighting

See file $VIMRUNTIME/syntax/c.vim for more advanced highlighting options for C files, like
- Highlighting of space errors
- Highlighting of curly, parens errors...

Highlight column:

:set colorcolumn=+1        " highlight column after 'textwidth'
:set colorcolumn=+1,+2,+3  " highlight three columns after 'textwidth'
:set colorcolumn=80        " highlight column 80
:highlight ColorColumn ctermbg=lightgrey guibg=lightgrey

Digraphs

Digraph is an easy way to enter special character in Vim, much easier than using ^V. See :help dig for more details.

code	result
`^k`.M	·
`^k`>>	»
`^k`PI	¶ (Pilcrow mark)
`^k`00	∞ (infinity)
`^k`(-	∈ (in)
`^k`In	∫ (integral)

viEmu

Tips for better use of viEmu.

Applying format in Word via keyboard. To apply format like bold or italic, you can't use the regular key binding C-b or C-i since it is intercepted by viEmu. Some work-arounds:
- (best) Use the new Ribbon shortcuts. For instance, A-h 1 for bold, A-h 2 for italic, Alt 3 for redo...
- (heavy) Temporarily disable viEmu with C-S-A-v. Say C-S-A-v C-b C-S-A-v for bold.
- (worsts) In the viEmu menu, tell viEmu not to intercept C-b and to pass it to Word.

In viEmu, don't let C-c to be passed to office app. This allows using C-C to leave insert mode.
In viEmu, don't Emulate vi/vim block caret. This allows formatting a single word w/o selecting it first, as usual in office.
In viEmu, don't Update display during long commands. Unchecking this box seems to fix the display glitch with viEmu status bar when scrolling down.

Editing HTML, XML, LaTeX

(for LaTeX, see also the vim-latex plugin)

Stackoverflow post

Use closetag
Use C-X C-O (omnicomplete) or define macro:

 imap ,/ </<C-X><C-O>

Use ragtag from Tim Pope (author of surround.vim)
Use sparkup (very efficient)

Define abbreviations (see [24])
Surround plugin in insert mode (use ^stli<enter> to insert a <li> tag for instance)
LaTex + surround plugin, use ysm\ to insert \begin{...} \end{...} environment.
To format LaTeX, see also plugin Latex Text Formatter.

Omni-Completion

Vim omni-completion C-X C-O is quite powerful. Example:

To insert HTML closing tags, type </C-X C-O

<sometag>
  some text
  some text
</C-X C-O

To complete a LaTeX tag. For instance to close a \begin environment, type C-X C-O C-O C-X C-O:

\begin{theorem}
  some text
  some text
C-X C-O C-O C-X C-O

A customization I used, but now disabled:

" C-N: Auto-completion menu
" # DISABLED - Don't like the extra window opened, and strange completion.
" # To try: CTRL-N, or CTRL-X CTRL-N, CTRL-X CTRL-O, CTRL-X CTRL-P...
inoremap <expr> <C-N> pumvisible() \|\| &omnifunc == '' ?
\ "\<lt>C-n>" :
\ "\<lt>C-x>\<lt>C-o><c-r>=pumvisible() ?" .
\ "\"\\<lt>c-n>\\<lt>c-p>\\<lt>c-n>\" :" .
\ "\" \\<lt>bs>\\<lt>C-n>\"\<CR>"

Use Vim as Hexadecimal Editor

From [25]

" To convert current buffer to hex
:%xxd
" To convert current buffer from hex
:%xxd -r

Use plugin hexman.vim. This still require to open vim in binary mode to prevent insertion of newlines (see [26]):

vim -b file             # Might still require ":set noeol"

vim ++bin file

vim file                # Then ':set binary' and ':set noeol'

Avoid the ESC key

BEST — Configure CapsLock as another ESC key.
- On Windows
- On Linux: gsettings set org.gnome.desktop.input-sources xkb-options "@as ['caps:escape']"
Use jj:

"--- jj -----------
" jj     : ... same as ESC (let's try) ...
inoremap jj <Esc>`^

Use Ctrl-C. Here with a fix to prevent the cursor to move one character on the left

"--- C-C ----------
" C-C    : Same as ESC, with an additional fix to prevent cursor move -- Note that ESC does move the cursor
inoremap <C-C> <Esc>`^

(No longer used) — Use Ctrl-Space.

"--- C-Space ------ ###DISABLED###. C-Space used for snippet completion instead.
" C-Space: NORMAL   --> ESC any prefix keys
" C-Space: VISUAL   --> ESC any selection (gV is required to prevent automatic reselection)
" C-Space: OPERATOR --> ESC any operator pending commands (like y)
" C-Space: INSERT   --> ESC insert mode and `^ restore cursor position (cursor does not move left)
"   (S-Space only works in GUI, see http://vim.wikia.com/wiki/Avoid_the_escape_key)
" nnoremap <nul> <Esc>     (disabled, conflicts with cscope shortcuts)
" vnoremap <nul> <Esc>gV
" onoremap <nul> <Esc>
" inoremap <nul> <Esc>`^

Use Alt-L, or any other Alt combination w/o side effect, since on most terminal Alt-key are sent as ESC-key.

Navigate `#ifdef`

Possibly install some plugins. None good found so far.
Use the standard map [# and ]# to navigate between #ifdef, and also % to cycle through them [27].

Using filetype (detection, plugins...)

Reference:

help filetype

Some commands:

:filetype         " Print file type status
:filetype detect  " Detect file type again
:echo &ft         " Print current file type

Detection

See help new-filetype. There are 4 methods:

Create a new autocommand and write this in a new file (e.g. ~/.vim/ftdetect/mine.vim. This will overrule default file type checks.
Same as above, but use setfiletype to set the file type. This will set the filetype only if no file type was detected yet.
If type can be detected from file name, create a new autocommand (in a augroup), and save it in file ~/.vim/filetype.vim. This will be sourced before default file type detection.
If type can only be detected by inspecting file content, create a vim script named ~/.vim/scripts.vim. This will be sourced before $VIMRUNTIME/scripts.vim.

Plugins

See help filetype-plugins. When filetype was detected, vim will look for available filetype plugins to set options and mappings local to the current buffer. There are 3 ways to create or update an existing filetype plugin:

Add a few settings before the default plugin. For this create a file in ~/.vim/ftplugin (for instance ~/.vim/ftplugin/fortran.vim).
Copy existing plugin. This will prevent default plugin to load.
Overrule the default plugin. For this create a file in ~/.vim/after/ftplugin (for instance ~/.vim/after/ftplugin/fortran.vim)

Note that vim looks for all plugins in runtimepath that match the filetype name, with an optional underscore and suffix (e.g. fortran.vim, fortran_custom.vim).

Debug

Start vim with vim -V2. Look for strings like Searching for "plugin/**/*.vim" in ~.

Compare files in Vim

References: stackexchange.com, vimcast.org.

:edit file1
:vsplit file2
:windo diffthis           " Start diff between both v-splits
:windo diffoff            " Stop diff

Indenting

To use an indent program that is configurable via environment variable INDENT:

if exists('$INDENT')
nnoremap <silent><leader>=    :call IndentBuffer()<CR>
endif

function! IndentBuffer()
  let cursor_position = getpos('.')     " Save the current cursor position
  silent exe "%!$INDENT 2>/dev/null"
  if v:shell_error
    undo
  endif
  call setpos('.',cursor_position)      " Restore the previous cursor position.
endfunction

Otherwise, use equalprg. By using a filetype auto-command, we can specify the file language to indent program [28]:

set equalprg=~/etc/indent.sh
autocmd FileType cpp setlocal equalprg=~/etc/indent.sh\ -l\ CPP
nnoremap <silent><leader>=    mzgg=G`z

Determine the highlight group under the cursor

" --- :HL -------------------------------------------------------------------------------------{{{
" Determining the highlight group that the word under the cursor belongs to ([http://mysite.verizon.net/astronaut/vim/index.html#Tags])
command! -bar -nargs=0 HL echo "hi<" . synIDattr(synID(line("."),col("."),1),"name") . '> trans<' . synIDattr(synID(line("."),col("."),0),"name") . "> lo<" . synIDattr(synIDtrans(synID(line("."),col("."),1)),"name") . ">"

Print to PDF

Linux

On Linux, print to file to generate a PS file:

:hardcopy > myfile.ps      " or :ha > myfile.ps

Then in bash:

ps2pdf myfile.ps

Windows

On windows, simply call :hardcopy:

:hardcopy

This will trigger the printer dialog. On Windows, one call also change the printer font:

    set pfn=Fantasque_Sans_Mono:h10:cANSI

Set `path` for `gf` (goto-file)

gf in vim opens the file whose name is under the cursor. By default vim looks into the current directory, but we can specify a list of directories to look into:

let &path.="src/include,/usr/include/AL,"

One can also give an expression to transform any string into filename. For instance, for java [29]:

set includeexpr=substitute(v:fname,'\\.','/','g')

Capture output of an ex command

:redir @a
:map           " The captured command
:redir END

Now content of command :map is in register "a.

Diff two files

Processing Input - Insert output of external command

Reference: http://vim.wikia.com/wiki/Use_filter_commands_to_process_text.

:r !ls     " read output from running ls, after current line
:0r !ls    " after line 0 (before first line)
:-r !ls    " before current line ("-" is ".-1")
:r !dir    " use 'dir' on Windows

Processing Input - Filter (pipe) buffer to external command

We use !pgm to call an external program. To pipe the current buffer to that program, just prefix the command with %:

:%!sort -u                          " Sort current buffer and remove duplicates

Prefix with a dot . to only filter the current line:

:.!sed 's/0/-/'                     " Replace all zeroes with - on current line

Pressing ! when in visual mode, apply the filter on the current selection. This is the same as:

:'<,'>!sed 's/0/-/'                  " Replace all zeroes with - on current selection

As a rule ! works as an operator, and hence works with motion as well:

!}sort          " sort from cursor to end of paragraph
3!}sort         " same, 3 paragraphs
3!!sort         " sort 3 lines

Save and restore a mapping

See stackexchange:

let map_save = maparg('<C-c>', 'n', 0, 1)

" do some stuff which changes the mapping

exe (map_save.noremap ? 'nnoremap' : 'nmap') .
    \ join(map(['buffer', 'expr', 'nowait', 'silent'], 'map_save[v:val] ? "<" . v:val . ">": ""')) .
    \ map_save.lhs . ' ' .
    \ substitute(map_save.rhs, '<SID>', '<SNR>' . map_save.sid . '_', 'g')

Edit a macro

Two methods [30]:

Editing the macro register in a buffer

"qp paste the contents of the register to the current cursor position
Edit the macro as necessary
"qy$ (and NOT "qyy" which adds an extra newline) to yank the modified macro back into the q register
dd delete the pasted register from the file your editing

Editing the macro register in the command line

:let @q=' open the q register
<C-r><C-r>q paste the contents of the q register into the buffer
Edit the macro as necessary
' add a closing quote, and Enter to finish editing the macro.

Fix spelling errors automatically

The following mapping will fix the last spelling error automatically [31]:

" C-l      : Auto-correct last mispelled word (https://castel.dev/post/lecture-notes-1/)
inoremap <C-l> <c-g>u<Esc>[s1z=`]a<c-g>u

The change can be undone with u as necessary.

This requires to enable and configure the spellcheck:

setlocal spell
set spelllang=nl,en_gb

Persistent session

Using :mksession one can save the current session state for later:

" Save session in Session.vim
:mksession
" Save session in lastsession.vim
:mksession lastsession.vim

For ease add the following lines at the end of our project.vim:

set sessionoptions+=blank,buffers,curdir,folds,help,options,resize,tabpages,winpos,winsize
source ./Session.vim

Now start editing with:

gvim -S project.vim

And before quiting Vim, do:

" Overwrite! Session.vim and quit
:mksession!
:wqa

This can be done automatically (see [32]). Add to your configuration file either of these autocmd:

" Update the session file only if one already exists
au VimLeave * if v:this_session != "" | exe "mksession! " . v:this_session | endif
" Or always save the session file
au VimLeave * mksession!

Edit powershell scripts with Vim

See this blog post.

Language tips

C/C++ (IDE)

Principle:

Use plugin TagList to get list of identifiers.
Use plugin mcf-make-target (to build any target from within Vim).
Use tip on persistent session.

Thanks to plugin TagList, it is possible to turn Vim into a simple yet efficient development IDE. The basic idea is to use the TagList window as a simple file explorer. We use a session file to add all files in the project to the TagList window. For C/C++ projects, we add our common settings/mapping defined in our cpp.vim.

Here an example session file project.vim:

" Project specific settings
set tags=./tags
TlistAddFiles src/*.cpp
TlistAddFiles src/*.h
" Source our custom cpp script
source ~/.vim/cpp.vim
" Session Persistence
au VimLeave * mksession!
set sessionoptions+=blank,buffers,curdir,folds,help,options,resize,tabpages,winpos,winsize
" Find in files
command! GREP :execute "grep -R <cword> ./src"|:cw
source Session.vim

Create the tag and cscope files:

ctags -R .
cscope -Rb

Then start the IDE session with:

gvim -S project.vim

Alternatively, one can use the filename Session.vim, and use the shorter command gvim -S.

Use the mappings A-Up / A-Down to switch the current window to the next/previous file. These mappings simply move and center the cursor in the TagList window to the previous/next file, open the file and put the cursor to its last position.

To build the project (assuming you have a valid Makefile in the project directory), just issue the command

:make

Optionally, we can set MAKEFLAGS:

let $MAKEFLAGS="-j"         " Enable parallel build

To easily navigate between the compilation errors, open the quickfix window:

" Open the window when there are compilation errors:
:cw
" Or open it always:
:cope

Finally you can run the program directly from Vim with:

:!./bin/myprogram
"To repeat the last :!{cmd}, do:
:!!

LaTeX (vimtex)

See vim-tex.

LaTeX (vim-latex) - OLD

Obsolete	We don't use this setup anymore.

Before using vimtex, we were using plugin Vim-latex.

To Do

Done Find a way to prevent vim to mess up with my register when deleting text.
Auto-complete, use cursor keys instead of up/down to search in the drop down list.
Look at Virtual-edit (see http://vim.wikia.com/wiki/Add_trailing_blanks_to_lines_for_easy_visual_blocks)
Other links:

http://www.faqs.org/docs/Linux-HOWTO/C-editing-with-VIM-HOWTO.html

http://www.ibiblio.org/pub/linux/docs/howto/translations/nl/onehtml/Vim-HOWTO-NL.html

NEW — Install neovim.
NEW — Install universal ctags.
NEW — Consider installing LSP (language-server protocol) for code completion as in VSCode (see Plugin page).
NEW — set clipboard+=unnamedplus; inoremap <C-V> <C-R>+; vnoremap <C-C> y; cnoremap <C-V> <C-R>+; as alternative for my clipboard mappings. Or apparently, set clipboard^=unnamedplus, which prepends the setting, is more recommended [33].
Look at https://kite.com as autocomplete alternative.

Troubleshooting

Here several methods to troubleshoot issues. See also the list of known issues for possible fix.

Startup time

Use this command to measure Vim startup time [34], [35]:

# Start VIM and exit immediately
rm -f vim.log && time vi --startuptime vim.log -c 'qa!' && tail vim.log
# ... or edit a file
 rm -f vim.log && vim --startuptime vim.log SOMEFILE

Profiling

We run the vim profiler [36]:

:profile start profile.log
:profile func *
:profile file *
" At this point do slow actions
:profile pause
:noautocmd qall!

Key mapping

Get the list of mappings, and where they were defined, for instance for the tab key:

:verbose imap <tab>

Known issues

Mapping portability

C-, only available to win32 gvim, not to cygwinX gvim.

Memory leaks

Command syn match may create memory leaks which slowly impact performance. Do the following as temporary fix (from [37]):

autocmd BufWinLeave * call clearmatches()

Slow cursor move (vertical / horizontal)

references: [38],
Can be due to cursorline. Try set nocursorline. Also remove any occurence of highlight CursorLine ...
Can be due to cursorcolumn. Try set nocursorcolumn. Also remove any occurence of highlight CursorColumn ...
Can be due to slow matchparen. Add to .vimrc:

let loaded_matchparen = 1
set noshowmatch

Can be improved with set lazyredraw

Meta - characters <M-x> (aka <Alt-x>) not working in console

Add the following to .vimrc, where ^[x is obtained with C-vC-x (from [39] and [40]):

set <M-x>=^[x

Note, this may also require the following in the shell console:

set convert-meta on

Although my current settings below also work it seems:

set meta-flag on
set convert-meta off
set input-meta on
set output-meta on

Another solution is to set the terminal in 8-bit mode as suggested in the link. This is however not possible with Gnome-terminal. A more advanced solution use a timeout to allow distinguishing between M-x and EscTemplate:X [41]:

let c='a'
while c <= 'z'
  exec "set <A-".c.">=\e".c
  exec "imap \e".c." <A-".c.">"
  let c = nr2char(1+char2nr(c))
endw

set timeout ttimeoutlen=50

Or use the following to have timeout only for keycodes and not other mappings:

set ttimeout ttimeoutlen=50

Terminal issues

Fixing Vim's Background Color Erase for 256-color tmux and GNU screen

Cannot unmap a mapping (no such mapping)

:map A gives

A  *@g$a

Trying to remove with :unmap A, we get the error

E31: No such mapping:

In fact the mapping is buffer local (see :h E1), and we need to remove it with

:unmap <buffer> A

Bugs

[2010-07-22] - (to bugs@vim.org) 'winfixheight' not honored when botright split is closed.

./wfh-bug.vim (<file name="wfh-bug.vim" tag="source">download</file>)

30 vnew
wincmd l
insert
We will open an horizontal split below, with wfh option set
Then we open a botright split, and close it immediately
Normally this window should recover its initial height, but if there is a vertical
split on the left, this window will be smaller
.
go
belowright 5 new
set wfh
insert
This window should only be 5 lines in height.
But it will be taller after closing the botright split if there is a vertical split
on the left
.
go
wincmd k
botright 10 split
q

[2011-07-27] - infinite loop when using :bn after a :edit dir/ (breaks plugin minibufexpl.vim)

Vi: Difference between revisions

Latest revision as of 10:00, 17 July 2023

References

Things to look at

External links

Vim help

Related projects

Universal ctags

Install

Building from Sources

Invocation

Using vimdiff

Plugins

Vim on Windows

Configuration

Color schemes

Tabs and indent

Cursor shape and mode

Managing Options

Scripting

Variables, environment variables and options

Expressions

Process control

Handy functions

Testing version, options and features

How-to

Frequent caveats

Mappings

View mappings

Define new mapping

Cheatsheets

Custom Cheatsheets

Mappings

Operators & motions

Commands

General tips

Practical Vim — Part I: Modes

Practical Vim — Part II: Files

Efficient Editing

Modeline

Miscellaneous

Spell checker

Command-line mode Tips

Clipboard support

Whitespaces

Advanced source highlighting

Digraphs

viEmu

Editing HTML, XML, LaTeX

Omni-Completion

Use Vim as Hexadecimal Editor

Avoid the ESC key

Navigate #ifdef

Using filetype (detection, plugins...)

Compare files in Vim

Indenting

Determine the highlight group under the cursor

Print to PDF

Set path for gf (goto-file)

Capture output of an ex command

Diff two files

Processing Input - Insert output of external command

Processing Input - Filter (pipe) buffer to external command

Save and restore a mapping

Edit a macro

Fix spelling errors automatically

Persistent session

Edit powershell scripts with Vim

Language tips

C/C++ (IDE)

LaTeX (vimtex)

LaTeX (vim-latex) - OLD

To Do

Troubleshooting

Startup time

Profiling

Key mapping

Known issues

Mapping portability

Memory leaks

Navigate `#ifdef`

Set `path` for `gf` (goto-file)