Vi: Difference between revisions

From miki
Jump to navigation Jump to search
Line 238: Line 238:
* Install [http://www.vim.org/scripts/script.php?script_id=2136 '''repeat.vim''' : Use the repeat command (.) with supported plugins]
* Install [http://www.vim.org/scripts/script.php?script_id=2136 '''repeat.vim''' : Use the repeat command (.) with supported plugins]
<li> [http://www.vim.org/scripts/script.php?script_id=1173 '''tComment''' : An extensible & universal comment plugin that also handles embedded filetypes]</li>
<li> [http://www.vim.org/scripts/script.php?script_id=1173 '''tComment''' : An extensible & universal comment plugin that also handles embedded filetypes]</li>
⚫
<li> [http://www.vim.org/scripts/script.php?script_id=521 '''mru.vim''' : Plugin to manage Most Recently Used (MRU) files]</li>
⚫
{{hiddenSourceFile|~/.vim/plugin/|mru.vim.diff|content=<source lang="diff" class="mru.vim.diff">
⚫
--- mru-old.vim 2010-06-29 00:45:59.000000000 +0200
⚫
+++ mru.vim 2010-07-22 14:14:19.000000000 +0200
⚫
@@ -657,7 +657,12 @@
⚫
let wcmd = '+buffer' . bufnum
⚫
endif
⚫
⚫
- exe 'silent! botright ' . g:MRU_Window_Height . 'split ' . wcmd
⚫
+ " MIP PATCH BEGIN - :botright conflicts with TagList + QuickFix windows
⚫
+ " if I have TagList + QuickFix window opened, calling :MRU multiple times makes the QuickFix window to grow
⚫
+ " endlessly
⚫
+ " exe 'silent! botright ' . g:MRU_Window_Height . 'split ' . wcmd
⚫
+ exe 'silent! ' . g:MRU_Window_Height . 'split ' . wcmd
⚫
+ " MIP PATCH END
⚫
endif
⚫
endif

⚫
</source>}}
<li> [http://www.vim.org/scripts/script.php?script_id=231 '''Smart Tabs''' : Use tabs for indent, spaces for alignment]</li>
<li> [http://www.vim.org/scripts/script.php?script_id=231 '''Smart Tabs''' : Use tabs for indent, spaces for alignment]</li>
* See also [http://vim.wikia.com/wiki/Indent_with_tabs%2C_align_with_spaces Indent with tabs & align with spaces]
* See also [http://vim.wikia.com/wiki/Indent_with_tabs%2C_align_with_spaces Indent with tabs & align with spaces]
<li> [http://www.derekwyatt.org/vim/working-with-vim-and-cpp/general-cpp-settings/ '''cpp.vim''': General C++ Settings (no indentation for namespace...)]</li>
<li> [http://www.derekwyatt.org/vim/working-with-vim-and-cpp/general-cpp-settings/ '''cpp.vim''': General C++ Settings (no indentation for namespace...)]</li>
'' (disabled highlight of leading tabs, line length overruns, unit test header test + nice <code>AlterColour</code> function that computes new colour...)''
'' (disabled highlight of leading tabs, line length overruns, unit test header test + nice <code>AlterColour</code> function that computes new colour...)''
⚫
<li> [http://www.vim.org/scripts/script.php?script_id=2158 '''diffchanges.vim''' : Show changes made to current buffer since the last save]</li>
<li> '''[http://cscope.sourceforge.net/cscope_maps.vim CScope]''' (also mirrored on [https://github.com/simplyzhao/cscope_maps.vim GitHub])</li>
<li> '''[http://cscope.sourceforge.net/cscope_maps.vim CScope]''' (also mirrored on [https://github.com/simplyzhao/cscope_maps.vim GitHub])</li>
* Cscope page is available on [http://cscope.sourceforge.net/ SourceForge].
* Cscope page is available on [http://cscope.sourceforge.net/ SourceForge].
Line 334: Line 314:
* After <code>:set path=/path/to/project/**</code>, one can do <code>:find filename.ext</code> (See [http://stackoverflow.com/questions/3241566/is-there-a-quick-way-with-macvim-nerdtree-plugin-to-find-a-file], more details at [http://vim.wikia.com/wiki/Find_files_in_subdirectories])
* After <code>:set path=/path/to/project/**</code>, one can do <code>:find filename.ext</code> (See [http://stackoverflow.com/questions/3241566/is-there-a-quick-way-with-macvim-nerdtree-plugin-to-find-a-file], more details at [http://vim.wikia.com/wiki/Find_files_in_subdirectories])
* To find a file in a sub-directory, use the fuzzy query <tt>**/filename</tt>
* To find a file in a sub-directory, use the fuzzy query <tt>**/filename</tt>
⚫
<li> [http://www.vim.org/scripts/script.php?script_id=2185 '''git:file.vim : open any version of a file in git]</li>
⚫
For instance, to open file <tt>filename.c</tt> at commit ''HEAD~4'':
⚫
<source lang=bash>
⚫
vim HEAD~4:./filename.c
⚫
</source>
<li>'''[http://vim-latex.sourceforge.net/ vim-latex]''' ([http://vim-latex.sourceforge.net/documentation/latex-suite.html documentation]</li>
<li>'''[http://vim-latex.sourceforge.net/ vim-latex]''' ([http://vim-latex.sourceforge.net/documentation/latex-suite.html documentation]</li>
<li> [http://vim.sourceforge.net/scripts/script.php?script_id=294 '''Align''' : Help folks to align text, eqns, declarations, tables, etc] (see [http://www.drchip.org/astronaut/vim/align.html#Examples examples])</li>
<li> [http://vim.sourceforge.net/scripts/script.php?script_id=294 '''Align''' : Help folks to align text, eqns, declarations, tables, etc] (see [http://www.drchip.org/astronaut/vim/align.html#Examples examples])</li>
Line 555: Line 530:
* <code>:Calendar</code> to launch. {{kbkey|<}} and {{kbkey|>}} to cycle through views, {{kbkey|E}} and {{kbkey|T}} to view Event list or Task list.
* <code>:Calendar</code> to launch. {{kbkey|<}} and {{kbkey|>}} to cycle through views, {{kbkey|E}} and {{kbkey|T}} to view Event list or Task list.
* <code>:Calendar 2001 1 1</code> to focus a specific date.
* <code>:Calendar 2001 1 1</code> to focus a specific date.
My settings in {{file|.vimrc}}:
⚫
</ul>
<source lang=vim>
" ----- Vim-Calendar ---------------------------------------------------------
let g:calendar_week_number=1
let g:calendar_first_day='monday'
⚫
</source>
⚫
<li> [http://www.vim.org/scripts/script.php?script_id=2158 '''diffchanges.vim''' : Show changes made to current buffer since the last save]</li>
* Never used. Functionality quite limited (only compared with last save). And if file is stored in Git, plugin '''fugitive''' is a much better alternative.
⚫
<li> [http://www.vim.org/scripts/script.php?script_id=521 '''mru.vim''' : Plugin to manage Most Recently Used (MRU) files]</li>
* Never used. And same functionality is available in '''Ctrl-P''' plugin anyway.
⚫
{{hiddenSourceFile|~/.vim/plugin/|mru.vim.diff|content=<source lang="diff" class="mru.vim.diff">
⚫
--- mru-old.vim 2010-06-29 00:45:59.000000000 +0200
⚫
+++ mru.vim 2010-07-22 14:14:19.000000000 +0200
⚫
@@ -657,7 +657,12 @@
⚫
let wcmd = '+buffer' . bufnum
⚫
endif
⚫
⚫
- exe 'silent! botright ' . g:MRU_Window_Height . 'split ' . wcmd
⚫
+ " MIP PATCH BEGIN - :botright conflicts with TagList + QuickFix windows
⚫
+ " if I have TagList + QuickFix window opened, calling :MRU multiple times makes the QuickFix window to grow
⚫
+ " endlessly
⚫
+ " exe 'silent! botright ' . g:MRU_Window_Height . 'split ' . wcmd
⚫
+ exe 'silent! ' . g:MRU_Window_Height . 'split ' . wcmd
⚫
+ " MIP PATCH END
⚫
endif
⚫
endif

⚫
</source>}}
⚫
<li> [http://www.vim.org/scripts/script.php?script_id=2185 '''git:file.vim : open any version of a file in git]</li>
⚫
For instance, to open file <tt>filename.c</tt> at commit ''HEAD~4'':
⚫
<source lang=bash>
⚫
vim HEAD~4:./filename.c
</source>
* Never used. Similar functionality available in plugin '''fugitive'''.
⚫
'</'ul>


== Color schemes ==
== Color schemes ==

Revision as of 06:14, 10 November 2016

Related Pages

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

  • Vimrc, which is dedicated to vim configuration settings and to the file ~/.vimrc.
  • Neovim, dedicated to new port of Vim.

External Links

General

Vi clones

General - Vim 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

Cheat sheets

Productivity & Setup Guides

Get the best Vim configuration

Tuned for Neovim

Guides & Cheat sheets

  • 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

Vim in Windows/Cygwin

Tips

: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

Use vim-plug to manage plugins.

Releated 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

Plugin Managers

Various plugin manager. My current favorite is vim-plug.

apt-vim

Fully-automated, Cross-platform Plugin Manager for Vim.

Pathogen

Plugin manager from Tim Pope.

VIM (vim-addon-manager)

VAM manage and install vim plugins (including their dependencies) in a sane way.

vim-plug

Plugin manager from junegunn, author of fzf, vim-easy-align.

Interaction with $HOME version control

If we store our HOME files (dot-files) in git, we can't store the plugins anymore because they are fetched and stored locally as squashed git submodules. We can circumvent this by managing these plugins as git submodules.

First create .gitmodules: 

[submodule "ack.vim"]
    path = .vim/plugged/ack.vim
    url = ./.vim/plugged/ack.vim
[submodule "auto-pairs"]
    path = .vim/plugged/auto-pairs
    url = ./.vim/plugged/auto-pairs
[submodule "a.vim"]
    path = .vim/plugged/a.vim
    url = ./.vim/plugged/a.vim

Then create the bare repositories: 

git clone --bare /home/peetersm home.git
cd home.git/
mkdir -p .vim/plugged
cd .vim/plugged
for g in ~/.vim/plugged/*; do git clone --bare $g; done

Then, to clone the HOME repository: 

git clone --recursive .../home.git

Finally we must update the tags file in vim. Start vim and run PlugInstall!. Ignore the error messages.


Troubleshooting
  • Using short path may fail if plugin name has an extension. For instance:
" The following FAILS because of trailing .vim
Plug 'ctrlpvim/ctrlp.vim'
" Use the following instead.
Plug 'https://github.com/ctrlpvim/ctrlp.vim.git'
  • Conditional plugin activation.
See the FAQ.

Plugins

Repositories

A mirror of all plugins originally found on http://www.vim.org/scripts/ ;
  • GitHub.

Getting help

  • Most plugins come with local help files. Do :help local-additions to get a list of help files for locally installed plugins.

Installed

Not yet installed

Some videos that illustrates those plugins:

Uninstalled

  • easytags.vim : Automated tag file generation and syntax highlighting of tags in Vim
    • Replaced by AutoTag — syntax highlighting of tags is limited to c files; moreover AutoTag has a clever way to look for the tags file in project hierarchy.
  • AutoClose : Inserts matching bracket, paren, brace or quote
    Don't like it much because inserting the closing pair will jump out of nested pair, which is annoying when one try to simply insert a closing brace (but a solution is to use the Surrond plugin to surround some selected text with braces).
  • trinity.vim : Build the trinity of srcexpl, taglist, NERD_tree to be a good IDE
  • minibufexpl.vim : Elegant buffer explorer - takes very little screen space
    • 1st attempt: No real tab support. Seems to interfere with trinity plugin. Interesting key bindings inside though. To reassess...
    • 2nd attempt: Don't care about tabs, the idea is to fully replace tabs with buffers since most plugins interface better with buffers. Disabled
    trinity plugin.
    • Closing a buffer: Use d in minibufexpl window to close a buffer, or :bd[elete] seems to work most of the time.
    • Uninstalled because found better alternative (bufstat)
  • LustyJuggler: Switch very quickly among your active buffers
    • Removed because I don't use it (LustyExplorer, NERDTree and FuzzyFinder are much better alternatives)
  • Latex Text Formatter : This scripts makes it easier to format latex text
    • Does not work well (line too short, line merge too aggressive)
  • calendar.vim - A calendar application for Vim
    • :Calendar to launch. < and > to cycle through views, E and T to view Event list or Task list.
    • :Calendar 2001 1 1 to focus a specific date.
    My settings in .vimrc: 
    " ----- Vim-Calendar ---------------------------------------------------------
let g:calendar_week_number=1
let g:calendar_first_day='monday'
  • diffchanges.vim : Show changes made to current buffer since the last save
    • Never used. Functionality quite limited (only compared with last save). And if file is stored in Git, plugin fugitive is a much better alternative.
  • mru.vim : Plugin to manage Most Recently Used (MRU) files
    • Never used. And same functionality is available in Ctrl-P plugin anyway.
  • git:file.vim : open any version of a file in git
    • For instance, to open file filename.c at commit HEAD~4: 
    vim HEAD~4:./filename.c
    • Never used. Similar functionality available in plugin fugitive.

    '</'ul>

    Color schemes

    Gruvbox (truecolor)

    A truecolor color scheme.

    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
    1. First, load the system config files:
      2. 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
    2. Second, load the user config files:
      3. File description OS Location
      vimrc User config file for vim and gvim Unix $HOME/.vimrc
      Win $HOME/_vimrc
      gvimrc User config file for gvim only Unix $HOME/.vimrc
      Win $HOME/_vimrc


    3. 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

    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 [12]):
      • 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.

    • 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

    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

    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 vs 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

    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 [13]: 

    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?

    Frequent caveats

    • Don't confuse variables and options. First are initialized with let, second 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"

    Simple C/C++ IDE using plugin TagList

    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

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

    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 [14]). 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!

    Troubleshoot

    • FuzzyFinder plugin complains about:
    Error detected while processing function 148..229..fuf#openTag:
line    1:
E432: Tags file not sorted: tags
    Tags were generated with ctags --sort=foldcase -R .
    Solution is to set option :set ignorecase

    Make with a custom target

    See plugin mcf-make-target above.

    Keyboard & Mouse Shortcuts

    • ! If keys HJKLM have been remapped to MHJKL, shortcut below must be changed accordingly !
    • Mouse shortcuts requires :set mouse=a.
    • Customer shortcuts are underlined

    Define new shortcuts

    • Note that not all combinations are possible (see [15] 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

    Custom Cheatsheets

    Plugin Cheatsheet

    Plugin - a

    :A
    :AS
    :AV
    :AT
    :AN
    :IH Cih
    :IHS
    :IHV
    :IHT
    :IHN Leaderihn
    Leaderis

    Switch between header / source file
    Split and Switch
    Vertical split and Switch
    New Tab and Switch
    Cycles through matches
    switches to file under cursor
    splits and switches
    vertical splits and switches
    new tab and switches
    cycles through matches
    switches to the alternate file of file under cursor

    Plugin - autoclose

    {{

    Insert & push closing brace down a new line

    Plugin - cscope_vim

    Leadercs ^Spaces
    Leadercg ^Spaceg
    Leadercc ^Spacec
    Leaderct ^Spacet
    Leaderce ^Spacee
    Leadercf ^Spacef
    Leaderci ^Spacei
    Leadercd ^Spaced
    ^Space^Space s
    :cs f s foo

    symbol: Find all references to token, split
    global: Find all global definitions, split
    call: Find all calls to function, split
    text: Find all instance of text, split
    egrep: egrep search, split
    file: open filename, split
    includes: Find all files that include fname, split
    called: Find functions that function calls, hsplit
    Same but vsplit
    Same but as command (use :scs for split)

    Plugin - diffchanges

    Leaderdcd
    Leaderdcp

    DiffChangesDiffToggle
    DiffChangesPatchToggle

    Plugin - MRU

    :MRU
    :MRU p
    CR
    o
    t
    v

    Open MRU file list
    Open MRU file list, only files containing p
    Open file in previous window if possible
    Open file in a new window
    Open file in a new tab
    Open file read-only (view)

    Plugin - Surround

    cs"'
    cs'<q>
    cst"
    ds"
    ysiw]
    yssb or yss)
    VmS<p id="a">
    ysibspace

    Change surrounding " to '
    Change surrounding ' to <q>...</q>
    Change surrounding tag back to "
    Remove the surrounding "
    Add [ ] around word (motion iw)
    Add ( ) around current line (ignoring leading ws)
    Add surrounding tag to selected lines
    Add surrounding blank inside current () block

    Plugin - taglist window (:help taglist-keys)

    [[ or BS
    ]] or Tab
    Space
    - or zc
    + or zo
    * or zR
    = or zM
    x
    CR or LMouse*2
    o O
    P
    p
    t
    u
    s

    Previous file
    Next file
    Show tag prototype
    Close a fold
    Open a fold
    Open all folds
    Close all folds
    Maximimze/Restore window
    Jump to tag location
    Jump to tag location (new window, vertical)
    Jump to tag location (in previous window)
    tag preview (cursor remains in taglist window)
    Jump to tag (new tab)
    Update tags
    Change the sort order

    Plugin - tComment

    gcm
    gcc
    gCm
    gCc

    Toggle comments motion
    Toggle comment for the current line
    Comment region motion
    Comment the current line

    Plugin - vim-latex

    ^m
    F5
    S-F5
    F7
    S-F7
    EEQ ,eq
    FSF `sf
    A-l
    A-b
    A-c
    A-o
    F6 \rf

    Jump to next
    Insert/expand/enclose in environment
    Change environment
    Insert/expand/enclose in command
    Change command
    Insert / enclose in equation
    Insert / enclose in font \textsf{}
    Expand ([|{<q or label
    Enclose in \\mathbf{}
    \\mathcal{} or \\cite{}
    Insert \\item{} (was A-i)
    Refresh folds

    Cheatsheet

    Window management

    ^W_ ^W| ^W=
    ^Wh ^Wl
    ^Wj ^Wk
    ^Wp
    ^Wo
    ^Wt

    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
    gMouseR ^MouseR

    Jump to tag
    Return from tag

    Command-line Mode (:)

    ^U
    ^R
    ^W

    		Remove auto-range (:help omap-info)

    Insert register / object (:help c_CTRL-R)
    Delete previous word

    Insert Mode

    ^Space
    ^O

    Same as Esc, but easier (see [16])
    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

    Miscellaneous

    ^^ or ^6 (azerty)

    Edit alternate buffer (#)

    Operator & motion

    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

    Tips for Efficient Editing

    • Dot command — See [17] for example.
    • Use * to search word under cursor (and # backward) &mdash see also [18] 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)
    • Quick variable renaming — Use the following mapping to search for last deleted word
      • " 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:

      1. Rename a variable with ciw for instance, and type the new variable name (use ^R- to start from old name)
      2. Look for next occurent of the replaced variable with F3 (or ù)
      3. Repeat replacement with . (dot key)
      4. 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 [19])
      • 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, ... [20]
      • . Add to .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
    • Use Caps Lock as another Escape (ESC) key.
      • On Linux, see X#Configuring_Layout_Options. Basically we update gnome settings for current user: 
      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

    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 /patternCR n N
      Scan document for previous match /patternCR
      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.

    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.

    Tips and Tricks

    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
      • To convert tabs in current file to current tab settings, use command :retab [21]. For instance to convert tabs into space 
      :set expandtab
:retab
    • View differences in vim
      • vimdiff file1.txt file2.txt
    • Interaction with X Clipboard
      • vim can use the X clipboard if it has been compiled with the clipboard feature (run vim --version and see if you have +clipboard in the output). In that case, yanking to the + register, or simply selecting with the mouse, will actually copy in the X clipboard, hence allowing other applications, or even other instances of vim to exchange text snippets. Also, it will ease the copy-paste of indented text, since in that case, vim will first disable autoindentation before pasting the text (see option paste). On system like Ubuntu, you need to install an instance of gvim (like package vim-gnome or vim-gtk) to have feature +clipboard turned on (i.e. installing package vim is not enough). When set mouse=a, use shift-mouse to still use the xterm copy/paste (see 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 ([22])
    • 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 [23]).
    • (from [24]), 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).
      • The previous solution was to use the settings below, but these break code folding with 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 [25])
      • 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 [26])
      • :w !sudo tee %
    • Delete all trailing spaces ([27]):
      • :%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 [28]: 

      " F10 - Remove all trailing whitespace
nnoremap <F10> :let _s=@/<Bar>:%s/\s\+$//e<Bar>:let @/=_s<Bar><CR>
    • Promote window to tab (see [29])
      • :noremap <C-W>t :tabedit <C-R>%<CR>gT<C-W>qgt
    • Find in files within Vim (commands :grep, :lgrep, :vimgrep, :lvimgrep)
      • Define this custom command to quickly look for current word, and displays the quicklist window: 
      " 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;
    • Use modeline to embed vim format settings in the document itself. This requires the following line in ~/.vimrc:
      • set modeline

      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: */
    • 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.

    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 —
      • One cannot define a user-defined in lower case with newcommand because Vim forces the command to start with an uppercase. But we can circumvent this requirement with an abbreviation [30]: 
      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. [31])
    • 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>> »
    ^kPI ¶ (Pilcrow mark)

    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)

    • 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 [32])
    • 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

    " 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 [34]):
    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.
    • 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 (prevent C-C to move one char on the left)
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>`^

    Plugins

    Install a plugin

    • Unzip the plugin in ~/.vim directory (or plugin, autoload...)
    • Generate the help tags with:
    helptags ~/.vim/tags

    vim-latex

    See page vim-latex.

    Building from Sources

    See

    To Do

    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

    Troubleshoot

    Mapping portability

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

    Miscellaneous

    • Command syn match may create memory leaks which slowly impact performance. Do the following as temporary fix (from [35]):
    autocmd BufWinLeave * call clearmatches()
    Slow cursor move (vertical / horizontal)
    • references: [36],
    • 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 [37] and [38]):
    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 [39]:
    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
    Troubleshoot startup speed issue
    • Vim can log the time to start each plugin [40]:
    vim --startuptime timing.log SOMEFILE

    Bugs

    • [2010-07-22] - (to bugs@vim.org) 'winfixheight' not honored when botright split is closed.
    • (2011-07-27) - infinite loop when using :bn after a :edit dir/ (breaks plugin minibufexpl.vim)
Retrieved from "https://miki.immie.org/mediawiki/index.php?title=Vi&oldid=8758"