Vim stands for 'Vi Improved'. Vi is the most popular and powerful editors in the Unix world. Vi is an abbreviation for "Visual" editor. One of the first editors was a line editor called 'ed' (and 'ex'). The Visual editor like Vi was a vast improvement over line editors like 'ed' (or 'ex'). The editors 'ed' and 'ex' are still available on Linux: see 'man ed' and 'man ex'.
A good editor improves programmer productivity. Vim supports color syntax highlighting of program code and also emphasises text using different fonts like normal, bold or italics. A color editor like Vim can improve the productivity of programmers by 2 to 3 times!! Programmers can read the code much more rapidly as the code syntax is colored and highlighted.
Before you install Vim, please refer to the OS specific release notes and information about compiling and usage of Vim at -
To use Vim install the following RPM packages on Redhat Linux -
rpm -i vim*.rpm
OR do this -
rpm -i vim-enhanced*.rpm
rpm -i vim-X11*.rpm
rpm -i vim-common*.rpm
rpm -i vim-minimal*.rpm
rpm -qa | grep ^vim | xargs rpm -ql | less
or
rpm -qa | grep ^vim | awk '{print "rpm -ql " $1 }' | /bin/sh | less
Note that the RPM packages for Redhat Linux use a Motif interface. If you have installed the GTK libraries on your system, consider compiling Vim from the source code for a clean GUI interface. For information on compiling Vim from the source code, see "Install Vim on Unixes", below.
To install Vim on Debian Linux (GNU Linux), login as root and when connected to internet type -
apt-get install vim vim-rt
For other flavors of unixes like Solaris, HPUX, AIX, Sinix, SCO download the source code file ( see Before you Install )
zcat vim.tar.gz | tar -xvf -
cd vim-5.5/src
./configure --enable-gui=motif
make
make install
For Windows 95/NT, download the Vim zip file. For Windows 95/NT you must download TWO zip files -
Get these two zip files ( see Before you Install ) Unpack the zip files using the Winzip http://www.winzip.com. Both the zip files (vim*rt.zip and vim*56.zip) must be unpacked in the same directory like say c:\vim.
For Windows 95/98, set the environment variable VIM in autoexec.bat by adding this line -
set VIM=c:\vim\vim56
VIM=c:\vim\vim56
The VIM variable should point to whereever you installed the vim56 directory. You can also set your PATH to include the gvim.exe's path.
You may need to logoff and relogin to set your environment. At an MS-DOS prompt type -
set vim
Create a short-cut on to your desktop by click-and-drag from c:\vim\vim56\gvim.exe. Copy the gvimrc_example file to the $VIM\_gvimrc. In my case it is c:\vim\vim56\_gvimrc.
You will need both the Unix and Extra archives to build vim.exe for VMS. For using Vim's full power you will need the runtime files as well. Get these files ( see Before you Install )
You can download precompiled executables from: http://www.polarfox.com/vim
VMS vim authors are -
Unpack the Unix and Extra archives together into one directory. In the <.SRC> subdirectory you should find the make file OS_VMS.MMS. By editing this file you may choose between building the character, GUI and debug version. There are also additional options for Perl, Python and Tcl support.
You will need either the DECSET mms utility or the freely available clone of it called mmk (VMS has no make utility in the standard distribution). You can download mmk from http://www.openvms.digital.com/freeware/MMK/
If you have MSS on your system, the command
> mms /descrip=os_vms.mms
will start building your own customised version of Vim. The equivalent command for mmk is:
> mmk /descrip=os_vms.mms
Vim uses a special directory structure to hold the document and runtime files:
vim (or wherever)
|- tmp
|- vim55
|----- doc
|----- syntax
|- vim56
|----- doc
|----- syntax
vimrc (system rc files)
gvimrc
Use:
> define/nolog device:[leading-path-here.vim] vim
> define/nolog device:[leading-path-here.vim.vim56] vimruntime
> define/nolog device:[leading-path-here.tmp] tmp
to get vim.exe to find its document, filetype, and syntax files, and to specify a directory where temporary files will be located. Copy the "runtime" subdirectory of the vim distribution to vimruntime.
Note: Logicals $VIMRUNTIME and $TMP are optional. Read more at :help runtime
Usually you want to run just one version of Vim on your system, therefore it is enough to dedicate one directory for Vim. Copy all Vim runtime directory structure to the deployment position. Add the following lines to your LOGIN.COM (in SYS$LOGIN directory). Set up logical $VIM as:
> $ define VIM device: <path>
Set up some symbols:
> $ ! vi starts Vim in chr. mode. > $ vi*m :== mcr device:<path>VIM.EXE > $ !gvi starts Vim in GUI mode. > $ gv*im :== spawn/nowait mcr device:<path>VIM.EXE -g
Create .vimrc and .gvimrc files in your home directory (SYS$LOGIN).
The easiest way is just rename example files. You may leave the menu file (MENU.VIM) and files vimrc and gvimrc in the original $VIM directory. It will be default setup for all users, and for users is enough just to have their own additions or resetting in home directory in files .vimrc and .gvimrc. It should work without problems.
Note: Remember, system rc files (default for all users) do not have the leading "." So, system rc files are:
> VIM$:vimrc > VIM$:gvimrc > VIM$:menu.vim
> sys$login:.vimrc > sys$login:.gvimrc
You can check that everything is on the right place with the :version command.
Example LOGIN.COM: > $ define/nolog VIM RF10:[UTIL.VIM] > $ vi*m :== mcr VIM:VIM.EXE > $ gv*im :== spawn/nowait mcr VIM:VIM.EXE -g > $ set disp/create/node=192.168.5.223/trans=tcpip
Note: This set-up should be enough if you are working in a standalone server or clustered environment, but if you want to use Vim as an internode editor, it should suffice. You just have to define the "whole" path:
> $ define VIM "<server_name>[""user password""]::device:<path>" > $ vi*m :== "mcr VIM:VIM.EXE"
as for example:
> $ define VIM "PLUTO::RF10:[UTIL.VIM]" > $ define VIM "PLUTO""ZAY mypass""::RF10:[UTIL.VIM]" ! if passwd required
You can also use $VIMRUNTIME logical to point to proper version of Vim if you have multiple versions installed at the same time. If $VIMRUNTIME is not defined Vim will borrow value from $VIM logical. You can find more information about $VIMRUNTIME logical by typing :help runtime as a Vim command.
VMS is not a native X window environment, so you can not start Vim in GUI mode "just like that". But it is not too complicated to get a running Vim.
1) If you are working on the VMS X console: Start Vim with the command: > $ mc device:<path>VIM.EXE -g or type :gui as a command to the Vim command prompt. For more info :help gui 2) If you are working on other X window environment as Unix or some remote X VMS console. Set up display to your host with: > $ set disp/create/node=<your IP address>/trans=<transport-name> and start Vim as in point 1. You can find more help in VMS documentation or type: help set disp in VMS prompt. Examples: > $ set disp/create/node=192.168.5.159 ! default trans is DECnet > $ set disp/create/node=192.168.5.159/trans=tcpip ! TCP/IP network > $ set disp/create/node=192.168.5.159/trans=local ! display on the same node
Note: you should define just one of these. For more information type $help set disp in VMS prompt.
Read the release notes for Vim on OS/2, see Before you Install .
At present there is no native PM version of the GUI version of vim: The OS/2 version is a console application. However, there is now a Win32s-compatible GUI version, which should be usable by owners of Warp 4 (which supports Win32s) in a Win-OS/2 session. The notes in this file refer to the native console version.
To run Vim, you need the emx runtime environment (at least rev. 0.9b). This is generally available as (ask Archie about it):
emxrt.zip emx runtime package
Read the release notes for Vim on OS/2, see Before you Install .
The author of Vim on Mac is
Eric Fischer 5759 N. Guilford Ave Indianapolis IN 46220 USA
Mac Bug Report When reporting any Mac specific bug or feature change, makes sure to include the following address in the "To:" or "Copy To:" field.
Vim compiles out of the box with the supplied CodeWarrior project when using CodeWarrior 9. If you are using a more recent version (e. g. CW Pro) you have to convert the project first. When compiling Vim for 68k Macs you have to open the "size" resource in ResEdit and enable the "High level events aware" button to get drag and drop working. You have to increase the memory partition to at least 1024 kBytes to prevent Vim from crashing due to low memory.
vim:ts=8:sw=8:tw=78:
To enable the syntax color highlighting you MUST copy the gvimrc file to your home directory. This will also put the "Syntax" Menu with gvim command. You can click on Syntax Menu and select appropriate languages like C++, Perl, Java, SQL, ESQL etc..
cd $HOME cp /usr/doc/vim-common-5.3/gvimrc_example ~/.gvimrc
" This line is a comment .... one which begins with double-quotes " The best is the bold font, try all of these and pick one.... set guifont=8x13bold "set guifont=9x15bold "set guifont=7x14bold "set guifont=7x13bold " " Highly recommended to set tab keys to 4 spaces set tabstop=4 set shiftwidth=4 " " The opposite is 'set wrapscan' while searching for strings.... set nowrapscan " " The opposite is set noignorecase set ignorecase
To see the list of available fonts on Linux/Unix see the command xlsfonts. Type -
bash$ xlsfonts | less
bash$ xlsfonts | grep -i bold | grep x
bash$ man xlsfonts
You can change the settings like color, bold/normal fonts in your $HOME/.gvimrc file. It is very strongly recommended that you set the background color to lightyellow or white with black foreground. Ergonomics says that best background color is lightyellow or white with black foreground. Hence change the variable 'guibg' in your $HOME/.gvimrc file as follows:
highlight Normal guibg=lightyellow
The sample gvimrc from /usr/doc/vim-common-5.3/gvimrc_example is as follows:
" Vim
" An example for a gvimrc file.
" The commands in this are executed when the GUI is started.
"
" To use it, copy it to
" for Unix and OS/2: ~/.gvimrc
" for Amiga: s:.gvimrc
" for MS-DOS and Win32: $VIM\_gvimrc
" Make external commands work through a pipe instead of a pseudo-tty
"set noguipty
" set the X11 font to use. See 'man xlsfonts' on unix/linux
" set guifont=-misc-fixed-medium-r-normal--14-130-75-75-c-70-iso8859-1
set guifont=8x13bold
"set guifont=9x15bold
"set guifont=7x14bold
"set guifont=7x13bold
"
" Highly recommended to set tab keys to 4 spaces
set tabstop=4
set shiftwidth=4
"
" The opposite is 'set wrapscan' while searching for strings....
set nowrapscan
"
" The opposite is set noignorecase
set ignorecase
" Make command line two lines high
set ch=2
" Make shift-insert work like in Xterm
map <S-Insert> <MiddleMouse>
map! <S-Insert> <MiddleMouse>
" Only do this for Vim version 5.0 and later.
if version >= 500
" I like highlighting strings inside C comments
let c_comment_strings=1
" Switch on syntax highlighting.
syntax on
" Switch on search pattern highlighting.
set hlsearch
" For Win32 version, have "K" lookup the keyword in a help file
"if has("win32")
" let winhelpfile='windows.hlp'
" map K :execute "!start winhlp32 -k <cword> " . winhelpfile <CR>
"endif
" Hide the mouse pointer while typing
set mousehide
" Set nice colors
" background for normal text is light grey
" Text below the last line is darker grey
" Cursor is green
" Constants are not underlined but have a slightly lighter background
highlight Normal guibg=grey90
highlight Cursor guibg=Green guifg=NONE
highlight NonText guibg=grey80
highlight Constant gui=NONE guibg=grey95
highlight Special gui=NONE guibg=grey95
endif
You can set some of the Vim properties in Xdefaults file.
WARNING: Do not set Vim*geometry as it will break the gvim menu, use Vim.geometry instead.
Edit the $HOME/.Xdefaults file and add the following lines:
! GVim great Colors. Vim*useSchemes: all Vim*sgiMode: true Vim*useEnhancedFSB: true Vim.foreground: Black !Vim.background: lightyellow2 Vim*background: white ! Do NOT use Vim*geometry , this will break the menus instead ! use Vim.geometry. Asterisk between Vim and geometry is not allowed. ! Vim.geometry: widthxheight Vim.geometry: 88x40 !Vim*font: -misc-fixed-medium-r-normal--20-200-75-75-c-100-iso8859-15-*5 Vim*menuBackground: yellow Vim*menuForeground: black
xrdb -merge $HOME/.Xdefaults
man xrdb
You can also edit the ~/.gvimrc file to change the background colors
gvim $HOME/.gvimrc
The best background color is lightyellow or white, with black foreground.
highlight Normal guibg=lightyellow
Instead of using "Syntax" menu you can also manually source in the syntax file. Edit the file with gvim and at : (colon) command give 'so' command. For example -
gvim foo.pc
:so $VIM/syntax/esqlc.vim
Each syntax file supports one or more default file name extensions, for example, JavaScript syntax file supports the *.js extension. If you happen to use an extension that conflicts with another default syntax file (such as adding JavaScript to a *.html file) than you can source in the additional syntax file with the command :so $VIM/syntax/javascript.vim. To avoid all of this typing, you can create a soft link like -
ln -s $VIM/syntax/javascript.vim js
gvim foo.html (... this file contains javascript functions and HTML)
:so js
You can use Vim in two modes - one with GUI and other without GUI. To use GUI use command -
gvim foo.cpp
vim foo.cpp
OR plain vanilla mode
vi foo.cpp
GUI mode gvim provides the following -
Generally Vim is used in conjunction with other powerful tools like ctags and gdb. ctags is for very rapid navigation through millions of lines of "C/C++" code and gdb is for debugging the "C/C++" code. A brief introduction of these two indispensable commands will be given in this chapter.
ctags is the most powerful command available for coding C, C++, Java, Perl, Korn/Bourne shell scripts or Fortran. Developers very extensively use ctags to navigate through thousands of functions within C/C++ programs. See 'man ctags' on Unix. It is very important that you learn how to use ctags to develop programs in C or C++, Java, etc.. Navigation is the single most important task while doing development of C or C++ code. Using ctags you can very quickly read the code by jumping from a calling line to the called function, drill down deeper into nested function calls, and unwind back all the way up to the top. You can go back and forth from function to function very quickly.
Without NAVIGATION you will be completely lost! ctags is like the magnetic COMPASS needle for the programmers.
Usage of ctags :
ctags *.cpp
gvim -t foo_function
gvim -t main
Inside the Vim editor, you can jump to a function by typing : (colon) tag < function name >as below -
:tag sample_function
If you want to jump into the function from a line in file which contains the function name, place the cursor just before the function name and press CTRL+] (press control key and left-square-bracket key simultaneously).
// example code
switch(id_number) {
Case 1:
if ( foo_function( 22, "abcef") == 3 )
^
|
|
|
Place the cursor here (just before foo_function) and press CTRL+]
This takes you to the function named "foo_function".
To come back to this line press CTRL+t
Since ctags does not directly support the Embedded SQL/C (ESQL) language, the following shell script can be used to create tags for esql. ESQL/C is database SQL commands embedded inside the "C" programs. Oracle's ESQL/C is called Pro*C and Sybase, Informix have ESQL/C and PostgreSQL has product "ecpg".
Save this file as "sqltags.sh" and do chmod a+rx tags_gen.sh.
#!/bin/sh
# Program to create ctags for ESQL, C++ and C files
ESQL_EXTN=pc
tag_file1=tags_file.1
tag_file2=tags_file.2
which_tag=ctags
rm -f $tag_file1 $tag_file2 tags
aa=`ls *.$ESQL_EXTN`
#echo $aa
for ii in $aa
do
#echo $ii
jj=`echo $ii | cut -d'.' -f1`
#echo $jj
if [ ! -f $jj.cpp ]; then
echo " "
echo " "
echo "***********************************************"
echo "ESQL *.cpp files does not exist.. "
echo "You must generate the *.cpp from *.pc file"
echo "using the Oracle Pro*C pre-compiler or Sybase"
echo "or Informix esql/c pre-compiler."
echo "And then re-run this command"
echo "***********************************************"
echo " "
exit
fi
rm -f tags
$which_tag $jj.cpp
kk=s/$jj\.cpp/$jj\.pc/g
#echo $kk > sed.tmp
#sed -f sed.tmp tags >> $tag_file1
#sed -e's/sample\.cpp/sample\.pc/g' tags >> $tag_file1
sed -e $kk tags >> $tag_file1
done
# Now handle all the C++/C files - exclude the ESQL *.cpp files
rm -f tags $tag_file2
bb=`ls *.cpp *.c`
aa=`ls *.$ESQL_EXTN`
for mm in $bb
do
ee=`echo $mm | cut -d'.' -f1`
file_type="NOT_ESQL"
# Exclude the ESQL *.cpp and *.c files
for nn in $aa
do
dd=`echo $nn | cut -d'.' -f1`
if [ "$dd" = "$ee" ]; then
file_type="ESQL"
break
fi
done
if [ "$file_type" = "ESQL" ]; then
continue
fi
rm -f tags
$which_tag $mm
cat tags >> $tag_file2
done
mv -f $tag_file2 tags
cat $tag_file1 >> tags
rm -f $tag_file1
# Must sort tags file for it work properly ....
sort tags > $tag_file1
mv $tag_file1 tags
The shell script given below can be used to generate tags for a very large variety of programs written in JavaScript, PHP/FI scripts, Korn shell, C shell, Bourne shell and many others. This is a very generic module.
Save this file as tags_gen.sh and do chmod a+rx tags_gen.sh.
#!/bin/sh
tmp_tag=tags_file
tmp_tag2=tags_file2
echo " "
echo " "
echo " "
echo " "
echo " "
echo "Generate tags for ...."
while :
do
echo " Enter file extension for which you want to generate tags."
echo -n " File-extension should be like sh, js, ksh, etc... : "
read ans
if [ "$ans" == "" ]; then
echo " "
echo "Wrong entry. Try again!"
else
break
fi
done
\rm -f $tmp_tag
aa=`ls *.$ans`
for ii in $aa
do
jj=`echo $ii | cut -d'.' -f1`
#echo $jj
cp $ii $jj.c
ctags $jj.c
echo "s/$jj.c/$ii/g" > $tmp_tag2
sed -f $tmp_tag2 tags >> $tmp_tag
\rm -f tags $jj.c
done
sort $tmp_tag > tags
\rm -f $tmp_tag $tmp_tag2
You would be using gdb extensively along with Vi. Debugging is the most important aspect of programming as the major cost of software projects goes into debugging and testing.
To debug C++/C programs use 'gdb' tool. See 'man gdb'. You must compile your programs with -g3 option like
gcc -g3 foo.c foo_another.c sample.c
To set up easy aliases do -
Setup an alias in your ~/.bash_profile
alias gdb='gdb -directory=/home/src -directory=/usr/myname/src '
Give -
gdb foo.cpp
gdb> dir /hom2/another_src
This will add to file search path
gdb> break 'some_class::func<TAB><TAB>
This will complete the function name saving you typing time... and will output like -
gdb> break 'some_class::function_foo_some_where(int aa, float bb)'
Pressing TAB key twice is the command line completion, which will save you lots of typing time. This is one of the most important technique of using gdb.
To get online help do -
gdb> help
Gives online help
gdb> help breakpoints
Gives more details about breakpoints.
To set breakpoints and do debugging
unixprompt> gdb exe_filename
gdb> b main
This will put breakpoint in main() function
gdb> b 123
This will put breakpoint in line 123 of the current file
gdb> help breakpoints
Gives more details about breakpoints.
To analyze the core dumps do
unixprompt> gdb exe_filename core
gdb> bt
Gives backtrace of functions and line numbers where the program failed
gdb> help backtrace
Gives more details about backtrace.
You can also use GUI version of gdb called xxgdb.
Memory leak tools -
See the online man pages. At unix shell prompt type 'man vim' and 'man gvim'.
Or inside the gvim session type :help to get the help page. See also Vim Tutorial
VIM - main help file
Move around: Use the cursor keys, or "h" to go left,
"j" to go down, "k" to go up, "l" to go right.
":1" takes you to 1st line of page
":n" takes you to nth line of page
"<SHIFT>g" takes you to bottom of page
":/someword/ will search for "someword" in doc
Close this window: Use ":q<Enter>".
Jump to a subject: Position the cursor on a tag between |bars| and hit CTRL-].
With the mouse: ":set mouse=a" to enable the mouse (in xterm or GUI).
Double-click the left mouse button on a tag between |bars|.
jump back: Type CTRL-T or CTRL-O.
Get specific help: It is possible to go directly to whatever you want help
on, by giving an argument to the ":help" command |:help|.
It is possible to further specify the context:
WHAT PREPEND EXAMPLE ~
Normal mode commands (nothing) :help x
Visual mode commands v_ :help v_u
Insert mode commands i_ :help i_<Esc>
command-line commands : :help :quit
command-line editing c_ :help c_<Del>
Vim command arguments - :help -r
options ' :help 'textwidth'
list of documentation files:
|howto.txt| how to do the most common things
|intro.txt| introduction to Vim
|index.txt| alphabetical index for each mode
|autocmd.txt| automatically executing commands on an event
|change.txt| delete and replace text
The home page of vim is at http://www.vim.org and mirror site in US is at http://www.us.vim.org
Vim FAQ is at http://www.grafnetix.com/~laurent/vim/faq.html and at http://www.vim.org/faq
Eli's Vim Page at http://www.netusa.net/~eli/src/vim.html
The Vi Lovers Home Page http://www.cs.vu.nl/~tmgil/vi.html
Vim Reference Guide at http://scisun.sci.ccny.cuny.edu/~olrcc/vim/
Vim mailing list at http://www.findmail.com/listsaver/vimannounce.html and http://www.vim.org/mail.html
Mailing list archives are kept at:
Vim macros
On Linux system see the tutorial at /usr/doc/vim-common-5.*/tutor, on other unix systems go to directory where vim is installed and look for doc directory.
bash$ cd /usr/doc/vim-common*/tutor
bash$ less README.txt
bash$ cp tutor $HOME
bash$ cd $HOME
bash$ less tutor
In this tutorial, we describe some "advanced" vi concepts and commands, so you can appreciate the power of vi and so you decide how to build your knowledge of vi commands. Nearly all vi references list the available commands, but many don't bother to discuss how the commands interrelate; this topic is the main purpose of this tutorial.
The vi cursor movement commands allow you to position the cursor in the file and/or on the screen efficiently, with a minimum number of keystrokes. There are oodles of cursor movement commands - don't try memorizing them all at once! Later, we'll see that much of the power of vi comes from mixing cursor movement commands with other commands to delete, change, yank (copy), and filter text.
Please edit a large text file (say, wknight) so you can experiment with each command as it is described. Keep in mind these commands will only work in Command Mode, not Insert Mode; if you start getting your "commands" in your text, press the ESC key to return to Command Mode.
Many of the movement commands discussed above can be preceded with a repeat count; the movement is simply repeated the given number of times:
We've seen that dd deletes the current line. This can be used with a repeat count: 3dd deletes three lines, the current line, and the two following lines.
The d command can be used as a "prefix" on most of the movement commands above to delete nearly arbitrary chunks of text. When used with d, the movement commands are called target specifiers. d can be given a repeat count. (As you try these experiments, remember to press u after each command to undo the deletion).
The c command is similar to d, except it toggles vi into Insert Mode, allowing the original (unwanted) text to be changed to something else.
For example, put the cursor on the beginning of a word (press w to get to the beginning of the next word). Then, press cw to change that word. On the screen, the last character in the word being changed will be replaced with a $ symbol indicating the boundary of the change; type in a new word (you will overwrite the original word on the screen) and press the ESC key when done. Your input may be longer or shorter than the word being changed.
Put the cursor at the beginning of a line containing at least three words, and try c3w to change three words. Try c$ to change to the end of the current line. In all cases where the change affects only the current line, the boundary of the change is indicated with $.
When a change affects more than just the current line, vi deletes the original text from the screen and toggles into Insert Mode. For example, try c3+ to change the current and the next three lines; vi deletes the four original lines from the screen and toggles into Insert Mode in a new blank line. As usual, press the ESC key when you have finished entering your new text.
Some other change commands:
The y command yanks a copy of text into a buffer; the yanked text can then be put (or pasted) elsewhere in the file using p or P.
The simplest form of yank is yy to yank the current line; after yy, try p to put a copy of the yanked line after the cursor. Following yy, you can make as many copies of the yanked line as you want by moving up and down in the file and pressing p.
To copy multiple lines, try, for example, 5yy (yank the current and next four lines). p puts a copy of the yanked lines after the cursor; the sequence 5yyp "works" but it probably doesn't do what you would like. The P command is like p, but puts a copy of the yanked text ahead of the cursor; try the sequence 5yyP.
Other yank commands:
The filter command !, prompts for the name of a UNIX command (which should be a filter), then passes selected lines through the filter, replacing those selected line in the vi buffer with the output of the filter command. vi's ability to pass nearly arbitrary chunks of text through any UNIX filter adds incredible flexibility to vi, at no "additional cost" in size or performance to vi itself.
Some examples will help illustrate. Create a line in your file containing just the word who and absolutely no other text. Put the cursor on this line, and press !! This command is analogous to dd, cc, or yy, but instead of deleting, changing, or yanking the current line, it filters the current line. When you press the second !, the cursor drops down to the lower left corner of the screen and a single ! is displayed, prompting you to enter the name of a filter. As the filter name, type sh and press the Return key. sh (the Bourne shell) is a filter! It reads standard input, does some processing of its input (that is, executes commands), and sends its output (the output of those commands) to standard output. Filtering the line containing who through sh causes the line containing who to be replaced with a list of the current users on the system - right in your file!
Try repeating this process with date. That is, create a line containing nothing but the word date, then put the cursor on the line, and press !!sh and the Return key. The line containing date is replaced with the output of the date command.
Put your cursor on the first line of the output of who. Count the number of lines. Suppose, for example, the number is six. Then select those six lines to be filtered through sort; press 6!!sort and the Return key. The six lines will be passed through sort, and sort's output replaces the original six lines.
The filter command can only be used on complete lines, not on characters or words.
Some other filter commands (here, < CR > means press Return):
You can mark lines and characters to be used as targest for movement, deletion, change, yanking, and filtering using the command mc, where c is a lowercase letter.
For example, put the cursor in the middle of some word and press ma. This marks the character under the cursor as mark a.
Now, move the cursor off the marked character and to a different line ( use the cursor keys, CTRL-u, or whatever). To return to the marked line, press 'a (that is, single quote, then a). This moves to the first non-white space character on the line containing mark a.
Move off that line again. To return to the marked character, press `a (that is, backquote, then a). This moves on top of the character marked with a.
Marking is usually used with deleting, changing, yanking or filtering. For example, move the cursor to a line other than the one containing mark a, and then press d'a (d, single quote, a). This deletes from the current line to and including the line marked with a.
Put the cursor in the middle of a different word and press mb to set mark b. Now, move the cursor away from that word (but only a few lines, so you can see what we're about to do more easily), and then press d`b (d, backquote, b). This deletes from the current CHARACTER to and including the CHARACTER marked with b.
As another example, to sort the output of who, mark the first line (ma), then move the cursor to the last line and press !'asort and the Return key.
If you jump to a mark and decide you want to jump back to whatever you jumped from, you can press '' (jump back to line) or `` (jump back to character).
When you delete, change, or yank text, the original text is stored (until the next delete, change, or yank) in an unnamed buffer from which it can be put using p or P. Using the unnamed buffer, only the most recently deleted, changed or yanked text may be recovered.
If you wish to delete, change, or yank multiple sections of text and remember them all (up to a maximum of 26), you can give a buffer name ahead of the delete change or yank command. A buffer name has the form "c (double quote, lowercase c).
For example, press "ayy to yank the current line into buffer a, then move to a different line and press "byy to yank that line into buffer b. Now, move elsewhere in the file and press "ap and "bp to put copies of the text stored in buffers a and b.
Some other named buffer commands:
To substitute one chunk of text for another in lines throughout your file, use the :s command. Some substitute examples:
All colon commands begin with a colon; when you press the colon, the cursor drops to the lower left corner of the screen, and a colon prompt is displayed waiting for you to finish your colon command.
Some important examples:
Various options affect the "feel" of vi. You can display all the various options that can be set using the colon command :set all. You can also use set to change options.
For example, if you want to see line numbers for the lines in the file you're editing, use the command :set number. To turn off line numbering, use the command :set nonumber. Most options can be abbreviated; :set nu turns on line numbering and :set nonu turns off line numbering.
If you :set nomagic, the special meanings of regular expression characters (period, asterisk, square bracket, etc.) are switched off. Use :set magic to restore the special meanings.
Some options take a value. For example, :set tabstop=4 causes tabs to be displayed as four space characters, rather than the usual eight.
If you find you always want certain options set certain ways, you can put the set commands you want ina file .exrc, or you can set up the environment variable EXINIT to specify the options you want.
For example, if your login shell is Bourne shell, this line could go in your .profile file:
EXINIT='set nomagic nu tabstop=4'; export EXINIT
setenv EXINIT 'set nomagic nu tabstop=4'
If you find you're performing a series of simple commands over and over, you can map the command series to an unused command key using the :map command. If your mapping must include control characters such as Return key (CTRL-M in ASCII) or the ESC (CTRL-[ in ASCII) key, precede such characters with CTRL-v to suppress their usual special meaning.
For example, this command maps CTRL-A to move the cursor forward 55 lines, then back up to the most recent blank line, then change that blank line to a formfeed (CTRL-L) and three blank lines. That is, each CTRL-A will paginate the next page, without splitting paragraphs across pages.
Note: In this command, each control character is shown as ^C, where C is some uppercase letter. For example, CTRL-M is shown as ^M. Also, when you enter this command you will not see the CTRL-v characters as shown: each CTRL-v merely suppresses the usual special meaning of the following control character, so when you press the sequence ^V^M, all you will see on the screen is ^M. In this command, ^M is the Return key and ^[ is the ESC key.
:map ^A 55+?^$^V^Mcc^V^L^V^M^V^M^V^M^V^[
You can edit multiple files with vi by giving multiple file names as command line arguments:
vi croc fatherw wknight
For example, try the following experiment: First get out of vi, then execute vi with croc and wknight as arguments:
$ vi croc wknight
/the < CR >
Yank this line into buffer a:
"ayy
Now go to the next file (you've made no change to croc, so this will work):
:n < CR >
Search for the "next" line containing the, without retyping the search string:
n
Put a copy of buffer a after the current line in wknight:
"ap
Move down two lines, and yank the current line into buffer b:
jj"byy
Save the changes to wknight
:w < CR >
Now, rewind to croc
:rew < CR >
Search again, and put a copy of buffer b after the found line:
n"bp
Save the changes, and exit vi
ZZ
This tutorial was intended to introduce some of the vi capabilities that you might overlook in your system's vi manual or that might not be mentioned in the manual (different systems have manuals of widely varying quality).
You will not be a vi expert after reading this tutorial, but you will have a good appreciation of vi's capabilities. Only time and effort can make a vi expert. But the efficiency and universality of vi make this effort pay off in the long run.
You may have decided you hate vi. So be it! But be aware that vi remains the standard UNIX text editor - the one editor you can count on being available on every UNIX system you'll use - so even if you prefer to use something else day-to-day, you'd be well advised to know the bare minimum vi material covered in this tutorial.
Vi has 3 modes:
Notations:
The "yank buffer" is filled by EVERY delete command, or explicitely by Y and yy.
Related VIM URLs are at -
This document is published in 11 different formats namely - DVI, Postscript, Latex, Adobe Acrobat PDF, LyX, GNU-info, HTML, RTF(Rich Text Format), Plain-text, Unix man pages and SGML.
This document is located at -
Also you can find this document at the following mirrors sites -
In order to view the document in dvi format, use the xdvi program. The xdvi program is located in tetex-xdvi*.rpm package in Redhat Linux which can be located through ControlPanel | Applications | Publishing | TeX menu buttons.
To read dvi document give the command -
xdvi -geometry 80x90 howto.dvi
And resize the window with mouse. See man page on xdvi.
To navigate use Arrow keys, Page Up, Page Down keys, also
you can use 'f', 'd', 'u', 'c', 'l', 'r', 'p', 'n' letter
keys to move up, down, center, next page, previous page etc.
To turn off expert menu press 'x'.
To read postscript document give the command -
gv howto.ps
To use ghostscript give -
ghostscript howto.ps
You can read HTML format document using Netscape Navigator, Microsoft Internet explorer, Redhat Baron Web browser or any other web browsers.
You can read the latex, LyX output using LyX a "X-Windows" front end to latex.
Copyright policy is GNU/GPL as per LDP (Linux Documentation project). LDP is a GNU/GPL project. Additional restrictions are - you must retain the author's name, email address and this copyright notice on all the copies. If you make any changes or additions to this document then you should notify all the authors of this document.