<!doctype linuxdoc system>
<linuxdoc>
<!-- 

************************** begin commentaar *****************************
        Hierna volgt de HOW-TO voor het instellen van de VIM-editor.
	Dit document staat in het SGML-formaat. Om dit document te
	verwerken moet je het sgml-package gebruiken.
************************* einde commentaar ******************************

-->
<!--
************************** SGML USER GUIDE *****************************
	De gebruikersgids voor SGML staat onder Linux in /usr/doc/sgml-tools
	Lees de example.sgml en guide.html documenten.
	Gebruik:
		HTML	  	sgml2html foo  (Geef hier de extensie .sgml niet op!!)
		Text	 	sgml2txt foo.sgml
		Latex	  	sgml2latex foo.sgml
		Postscript 	sgml2latex -language=english -o ps foo.sgml
		DVI  		sgml2latex -d foo.sgml
		Lyx		sgml2lyx foo.sgml
		Richtext 	sgml2rtf foo.sgml
		gnuinfo  	sgml2info foo.sgml
		man		sgml2txt -man foo.sgml
		SGML	 	sgmlcheck foo.sgml
************************* einde commentaar *****************************
-->

<article>

<!-- Titel informatie -->
<titlepag>
<title>Vim Color Editor HOW-TO (Vi Improved met syntax color highlighting) 
</title>
<!-- chapt change
Vim Color Editor HOW-TO
Vi Improved met syntax color highlighting

-->
<author><name>Al Dev (Alavoor Vasudevan) <htmlurl url="mailto:alavoor@yahoo.com"
name="alavoor@yahoo.com"><newline>
Vertaald door: Ellen Bokhorst <htmlurl url="mailto:bokkie@nl.linux.org"
name="bokkie@nl.linux.org"></name></author>
<date>v5.0, 04 maart 2000</date>
<abstract>
Dit document is een leidraad voor het snel instellen van de Vim-kleuren
editor onder Linux- of Unix-systemen. De informatie hierin zal de
productiviteit van een programmeur verhogen aangezien de Vim-editor
ondersteuning biedt voor syntax color highlighting en bold fonts die de
"leesbaarheid" van programmeercode verbetert. De productiviteit van
programmeurs wordt met 2 tot 3 keer verbeterd door gebruik te maken van
een kleureneditor zoals Vim. De informatie in dit document geldt voor alle
besturingssystemen waaronder Vim werkt, dat zijn - Windows 95/NT en alle
soorten Unix zoals Linux, Solaris, HPUX, AIX, SCO, Sinix, BSD, SCO, enz..
</abstract>
</titlepag>
<toc>

<sect><heading>Introductie</heading>
<p>
Vim editor staat voor 'Vi IMproved'. Vi is de populairste en krachtigste
editor in de Unix-wereld. De <bf>Vi</bf> is een afkorting voor
"<it><bf>Vi</bf></it>sueel" editor. Vroeger was de eerste editor
op deze planeet een regeleditor genaamd 'ed' (en 'ex'). De 
<it><bf>Vi</bf></it>suele editor zoals Vi was een reusachtige verbetering
in vergelijking met regeleditors als 'ed' (of 'ex'). De editors 'ed' en
'ex' zijn nog steeds beschikbaar onder Linux, zie 'man ed' en 'man ex'.
</p>
<p>
Een goede editor zal de productiviteit van de
programmeur verbeteren. Vim biedt ondersteuning voor color syntax 
highlighting van programma-code en tevens benadrukking door gebruik te
maken van verschillende fonts als normaal, vet of cursief. 
Een kleureneditor als Vim zal de <bf>productiviteit</bf> bij het programmeren
met een factor 2 tot 3 verhogen!! Programmeurs kunnen de code veel sneller
lezen aangezien de syntax van de code in kleur en opgelicht wordt weergegeven.
</p>

<sect1><heading>Installatie van Vim onder Redhat Linux</heading>
<p>
Installeer de volgende RPM-packages om Vim onder Redhat Linux te installeren -
<code>
	rpm -i vim*.rpm

OF gebruik dit -
	rpm -i vim-enhanced*.rpm
	rpm -i vim-X11*.rpm
	rpm -i vim-common*.rpm
	rpm -i vim-minimal*.rpm
</code>
Je kan een lijst te zien krijgen van de bestanden die het rpm-package van
vim installeert met - 
<code> 
	rpm -qa | grep ^vim | awk '{print "rpm -ql " $1 }' | /bin/sh | less
</code>
en hier doorheen bladeren met j,k, CTRL+f, CTRL+D, CTRL+B, CTRL+U of door 
gebruik te maken van de pijltjestoetsen, page up/down toetsen.
Zie 'man less'.
</p>
</sect1>

<sect1><heading>Installatie van Vim onder GNU Debian Linux</heading>
<p>
Voor de installatie van Vim onder Debian Linux (GNU Linux) log je in als
root en wanneer je bent verbonden met het internet type je:
<code>
apt-get install vim vim-rt
</code>
</p>
<p>
Hiermee zal de laatste versie van vim worden gedownload, ge&iuml;nstalleerd
en geconfigureerd en zal het 't .deb bestand dat werd gedowload, worden
verwijderd. Het eerst opgesomde package is vim, de standaard editor, 
gecompileerd met X11-ondersteuning, vim-rt is de vim runtime, het bevat
alle syntax- en helpbestanden.
</p>
</sect1>


<sect1><heading>Vim onder diverse Unix-en installeren</heading>
<p>
Download voor andere varianten van unix, zoals Solaris, HPUX, AIX, Sinix,
SCO het broncode bestand

<code> 
	zcat vim.tar.gz | tar -xvf -
	cd vim-5.5/src
	./configure --enable-gui=motif
	make
	make install
</code>
</p>
</sect1>

<sect1><heading>Vim installeren onder Microsoft Windows 95/NT</heading>
<p>
Voor Windows 95/NT moet je <bf>TWEE</bf> zip-bestanden downloaden.
<itemize>
<item> Runtime ondersteuningsbestand <bf>vim*rt.zip</bf></item>
<item> Vim opdrachtenbestand <bf>vim*56.zip</bf>. Hier is de Vim-versie 5.6
</item>
</itemize>
Haald deze twee zipbestanden op vanaf -
<itemize>
<item> De homepage van vim: <url url="http://www.vim.org"></item>
<item> Een mirror site in US: <url url="http://www.us.vim.org"></item>
</itemize>
Pak de zip-bestanden uit met behulp van Winzip <url url="http://www.winzip.com">. Beide zip-bestanden (vim*rt.zip en vim*56.zip) moeten in dezelfde directory,
bv in <bf>c:\vim</bf> worden uitgepakt.

Stel de omgeving VIM in in autoexec.bat en plaats daarin deze regel -
<code>
set VIM=c:\vim\vim56
</code>
Vim zou daarnaar moeten verwijzen daar waar je de vim56 directory installeerde.
Je kunt je PATH ook zo instellen dat het pad naar gvim.exe erin voorkomt.

Mogelijk moet je uitloggen en weer inloggen om je omgeving in te stellen.
Typ achter de MS-DOS prompt -
<code>
set vim
</code>
En je zou moeten zien: VIM=c:\vim\vim56

Maakt een snelkoppeling aan op je desktop door te klikken en slepen
vanuit c:\vim\vim56\gvim.exe. Kopieer het bestand gvimrc_example naar
$VIM\_gvimrc. In mijn geval is dit c:\vim\vim56\_gvimrc.
</p>
</sect1>
</sect>


<sect><heading>Stel de init-bestanden van gvim in</heading>
<p>
Je MOET het bestand gvimrc naar je homedirectory kopi&euml;ren om
de syntax color highlighting te activeren. 
Hierdoor zal ook het "Syntax" Menu met de gvim-opdracht worden geplaatst.
Je kunt op het Syntax-Menu klikken en de van toepassing zijnde talen
selecteren, zoals C++, Perl, Java, SQL, ESQL enz..
<CODE>
cd $HOME
cp /usr/doc/vim-common-5.3/gvimrc_example  ~/.gvimrc
</CODE>
Commentaarregels beginnen in .gvimrc met dubbele aanhalingstekens (").
Je kunt gvim aanpassen door het wijzigen van het bestand $HOME/.gvimrc 
en daar de volgende regels in plaatsen - 
<CODE>
"Deze regel is commentaar .... &eacute;&eacute;n die met dubbele aanhalingstekens begint
" Het beste is het bold-font, probeer ze allemaal en kies er &eacute;&eacute;n uit....
set guifont=9x15bold
"set guifont=8x13bold
"set guifont=7x14bold
"set guifont=7x13bold
"
"Beslist aan te raden de tabtoetsen op 4 in te stellen.
set tabstop=4
set shiftwidth=4
"Het tegengestelde is 'set wrapscan' bij het zoeken naar strings....
set nowrapscan
"
"Het tegengestelde is noignorecase
set ignorecase
</CODE>
Het word je <bf>ten zeerste</bf> aanbevolen de tabstop en shiftwidth op
4 in te stellen.

De tabstop is het aantal spaties dat door TAB zal worden geplaatst als je
met gvim aan het werken bent. De shiftwidth is het aantal spaties waarmee
de regels zullen worden verschoven bij gebruik van de ">>" of "<<" opdrachten
van vi. Raadpleeg de tutorials van Vi <ref id="Vim Tutorial"> voor meer details.

Zie de opdracht <bf>xlsfonts</bf> voor een lijst met beschikbare fonts
onder Linux/Unix. Typ
<code>
	bash$ xlsfonts | less
	bash$ xlsfonts | grep -i bold | grep x
	bash$ man xlsfonts
</code>
</p>

<sect1><heading>Voorbeeld gvimrc bestand</heading>
<p>
Je kunt de instellingen, zoals kleuren, bold/normale fonts in het $HOME/.gvimrc
bestand wijzigen.
Het wordt <bf>ten zeerste</bf> aanbevolen dat je de achtergrondkleur
op <tt>lichtgeel</tt> of <tt>wit</tt> met een <tt>zwarte</tt> voorgrond
instelt. Ergonomen zeggen dat de beste achtergrondkleur
<tt>lichtgeel</tt> of <tt>wit</tt> met een zwarte voorgrond is. Wijzig
daarom als volgt de variabele 'guibg':
<code>
	highlight Normal guibg=lightyellow
</code>

Het voorbeeld gvimrc vanuit /usr/doc/vim-common-5.3/gvimrc_example luidt
als volgt (vertaalde versie):
<code>
" Vim
" Een voorbeeld gvimrc bestand.
" De opdrachten hierin worden uitgevoerd wanneer de GUI wordt opgestart.
"
" Kopieer het voor gebruik naar
"     voor Unix en OS/2:  ~/.gvimrc
"            voor Amiga:  s:.gvimrc
"  voor MS-DOS en Win32:  $VIM\_gvimrc

" Zorg dat externe opdrachten via een pipe in plaats van een pseudo-tty werken
"set noguipty

" stel het te gebruiken X11-font in. Zie onder unix/linux 'man xlsfonts'.
" 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
"
"Beslist aan te raden de tabtoetsen op 4 in te stellen.
set tabstop=4
set shiftwidth=4
"Het tegengestelde is 'set wrapscan' bij het zoeken naar strings....
set nowrapscan
"
"Het tegengestelde is noignorecase
set ignorecase

" Stel de opdrachtregel in op 2 regels
set ch=2

" shift-insert werkt net als in Xterm
map <S-Insert> <MiddleMouse>
map! <S-Insert> <MiddleMouse>

" Doe dit alleen voor Vim versie 5.0 en later.
if version >= 500

  " Ik vind 't prettig als strings in C commentaar wordt opgelicht
  let c_comment_strings=1

  " Schakel syntax highlighting in.
  syntax on

" Schakel zoekpatroon highlighting in.
set hlsearch

" Voor Win32 versie, "K" zoekt het sleutelwoord in een helpbestand
"if has("win32")
"  let winhelpfile='windows.hlp'
"  map K :execute "!start winhlp32 -k <cword> " . winhelpfile <CR>
"endif

" Verberg de muisaanwijzer tijdens het typen
set mousehide

" Stel fraaie kleuren in
" achtergrond voor normale tekst is lichtgrijs
" Tekst onder de laatste regel is donkergrijs
" Cursor is groen
" Constanten worden niet onderstreept maar hebben een iets lichtere achtergrond
  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
</code>
Zie ook het voorbeelbestand vimrc in /usr/doc/vim-common-5.3/vimrc_example dat
voor onder de console wordt gebruikt 
</p>
</sect1>


<sect1><heading>Xdefaults parameters</heading>
<p>
Je kunt een aantal eigenschappen van Vim in het bestand Xdefaults plaatsen.

<bf> WAARSCHUWING!! WAARSCHUWING: </bf>Plaats hierin niet de
<bf>Vim*geometry</bf>; het zal het menu van gvim opbreken, gebruik hier
voor in de plaats <bf>Vim.geometry</bf>. 

Wijzig het bestand $HOME/.Xdefaults en plaats hierin de volgende regels:
<CODE>
! GVim great Colors.
Vim*useSchemes:		all
Vim*sgiMode:		true
Vim*useEnhancedFSB:	true
Vim.foreground:		Black
!Vim.background:	lightyellow2
Vim*background:		white
! Gebruik GEEN Vim*geometry, dit zal de menu's opbreken, gebruik in plaats
! daarvan Vim.geometry. Een asteriks tussen Vim en geometry is niet toegestaan.
! 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
</code>
Dit heeft effect na het intikken van -
<code>
	xrdb -merge $HOME/.Xdefaults
	man xrdb
</code>

Je kunt ook het bestand &tilde;/.gvimrc wijzigen om de achtergrondkleuren te veranderen.
<code>
	gvim $HOME/.gvimrc
De beste achtergrondkleur is lichtgeel of wit.
highlight Normal guibg=lightyellow
</code>
</p>
</sect1>
</sect>

<sect><heading>Kleuren Syntax init bestanden</heading>
<p>
In plaats van gebruik te maken van het "Syntax" menu kun je 
het syntax-bestand ook handmatig bewerken.
Wijzig het bestand met gvim   
en achter de : (dubbele punt) opdracht geef je de 'so' opdracht. Bijvoorbeeld -
<CODE>
	gvim foo.pc
	:so $VIM/syntax/esqlc.vim
</CODE>
De syntax source-bestanden staan in /usr/share/vim/syntax/*.vim. 
Vim ondersteunt meer dan 120 verschillende syntax-bestanden voor verschillende
talen zoals C++, PERL, VHDL, Javascript,... enzovoort!!

Ieder syntaxbestand ondersteunt een standaardnaam voor de bestandsextensie,
het syntaxbestand voor Javascript bijvoorbeeld, ondersteunt de extensie *.js.
Mocht het je gebeuren dat je een andere extensie gebruikt die een conflict
veroorzaakt met een ander standaard syntaxbestand zoals bij het plaatsen
van Javascript in een *.html bestand, dan MOET je de opdracht
:so $VIM/syntax/javascript.vim gebruiken. De beste methode is een softlink
aan te maken zoals
<code>
ln -s $VIM/syntax/javascript.vim js
gvim foo.html (... dit bestand bevat javascript functies en HTML)
:so js
</code>
</p>
</sect>


<sect><heading>VIM Gebruik</heading>
<p>
Je kunt Vim in twee modi gebruiken - &eacute;&eacute;n met GUI en
de andere zonder GUI. Om de GUI te gebruiken geef je de volgende opdracht -
<code>
	gvim foo.cpp
</code>
Om de niet-gui modus te gebruiken tik je in -
<code>
	vim foo.cpp
OF plain vanilla modus
	vi foo.cpp
</code>
Het is ten zeerste aan te raden dat je altijd gebruik maakt van gvim
in plaats van vim, aangezien de GUI mode met kleuren je productiviteit
beslist zal verbeteren.

De GUI mode voorziet in het volgende -
<itemize>
<item> Je kunt de tekst met de muis markeren om te knippen, kopi&euml;ren,
en plakken.</item>
<item> Je kunt de Menubalk met de File, Edit, Window, Tools, Syntax en
Help knoppen items gebruiken.</item>
<item> In de nabije toekomst van gvim zal een tweede menubalk de lijst
met de te wijzigen bestanden tonen, en kun je tussen bestanden schakelen
door op de bestandsnamen te klikken, tot dan kun je gebruik maken van de
vi-opdrachten -:e#, :e#1, :e#3, :#4, ...enzovoort om de bestanden te
selecteren.</item>
</itemize>
</p>
</sect>


<sect><heading>Vi bondgenoten</heading>
<p>
In het algemeen wordt Vim in samenwerking met andere krachtige tools zoals
<bf>ctags</bf> en <bf>gdb</bf> gebruikt. De <bf>ctags</bf> is voor zeer
snelle navigatie door miljoenen regels "C/C++" code en <bf>gdb</bf>
voor het debuggen van de "C/C++" code. Een beknopte introductie van deze
twee onmisbare opdrachten zal in dit hoofdstuk worden gegeven.
</p>
<p>
De <bf>ctags</bf> is de krachtigste beschikbare opdracht voor het coderen
in C, C++, Java, Perl, Korn/Bourne shell scripts of Fortran. Ontwikkelaars
gebruiken <bf>ctags</bf> zeer uitgebreid om "naar en vanuit" duizende functies
C/C++ programma's te navigeren. Zie onder Unix 'man ctags'. Het is 
<bf>zeer belangrijk</bf> dat je MOET leren hoe deze ctags te gebruiken om
programma's in C of C++, Java, enz.. te ontwikkelen. Navigatie is de 
belangrijkste taak tijdens het ontwikkelen in C of C++ code. Met behulp van
ctags kun je de code zeer snel lezen door te springen van de aanroepende
regel naar de functie en dieper in geneste functie-aanroepen gaan en naar
het begin teruggaan. Je kunt zeer snel heen en weer van functie naar
functie gaan.

Zonder NAVIGATIE zal je waarschijnlijk verloren zijn! <bf>ctags</bf> is als
de magnetische KOMPAS naald voor de programmeurs.

Gebruik van <bf>ctags</bf> : 
<code>
	ctags *.cpp
	gvim -t foo_function
	gvim -t main
</code>
Hiermee zal het C++ programmabestand met daarin de functie foo_funtion()
worden gewijzigd en zal de cursor automatisch op de eerste regel van de
funtie foo_funtion() worden geplaatst.
De tweede opdracht brengt je naar de regel met de main() functie
definitie.

Binnen de Vim editor, kun je naar een functie springen door het intikken van
een : (dubbele punt) tag
&lt functie naam &gt als hieronder -
<code>
	:tag voorbeeld_functie
</code>
Hiermee zal de cursor op de eerste regel van voorbeeld_functie() worden
geplaatst.

Als je binnen de functie naar een regel met de naam van de functie wilt
springen, plaats je de cursor direct voor de naam van de functie en druk
je op <bf>CTRL+]</bf> (druk tegelijkertijd op de control-toets en linker
blokhaak), hierdoor zal je automatisch direct rechts van de regel 
terechtkomen waar de functie begint!!
<code>
		// voorbeeldcode
		switch(id_number) {
			Case 1:
				if ( foo_function( 22, "abcef") == 3 )
				    ^
				    |
				    |
				    |
		  Plaats de cursor hier (direct voor foo_function) en druk op CTRL+]
		  Hierdoor zal je naar de functie met de naam "foo_function" gaan. 
                  Druk op CTRL+t om naar deze regel terug te keren.
</code>
Druk op <bf>CTRL+t</bf> (Control-toets en letter 't' samen) om terug te gaan
naar de aanroepende regel.
Je blijft de <bf>CTRL+t</bf> indrukken om terug te gaan en naar de
eerste regel te gaan vanwaar je de navigatie begon.
Dat wil zeggen dat je de
<bf>CTRL+]</bf> in kan blijven drukken en dan de <bf>CTRL+t</bf> om terug
te gaan. Je kunt dit zovaak herhalen als je wilt voor volledige navigatie
door de C of C++ functies.
</p>



<sect1><heading>Ctags voor ESQL</heading>
<p>
Aangezien ctags de Embedded SQL/C (ESQL) taal niet direct ondersteunt, kan
het volgende script worden gebruikt om tags voor esql aan te maken.
ESQL/C zijn database SQL opdrachten embedded binnen de "C" programma's.
Oracle's ESQL/C wordt Pro*C genoemd en Sybase, Informix heeft ESQL/C en
PostgreSQL heeft het produkt "ecpg".
</p>
<p>
Bewaar dit bestand als "sqltags.sh" en pas een a+rx tags_gen.sh toe.
<code>
#!/bin/sh

# Programma om ctags voor ESQL, C++ en C bestanden aan te maken
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 bestanden bestaan niet.. "
		echo "Je moet de *.cpp vanuit het *.pc bestand genereren"
		echo "met behulp van de Oracle Pro*C pre-compiler of Sybase"
		echo "of Informix esql/c pre-compiler."
		echo "En vervolgens deze opdracht weer opnieuw uitvoeren"
		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

# Handel nu alle C++/C bestanden af - sluit de ESQL *.cpp bestanden uit
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"
	# Sluit de ESQL *.cpp en *.c bestanden uit
	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

# Moet tags bestand sorteren wil het juist werken ....
sort tags > $tag_file1
mv $tag_file1 tags
</code>
</p>
</sect1>


<sect1><heading>Ctags voor Javascript programma's, Korn, Bourne shells
</heading>
<p>
Het hieronder gegeven shell-script kan worden gebruikt om tags voor een
zeer grote vari&euml;teit aan programma's geschreven in 
variety of programs written in JavasScript, PHP/FI scripts, Korn shell,
C shell, Bourne shell en vele anderen te genereren. Dit is een zeer algemene
module.

Bewaar dit bestand als tags_gen.sh en pas een chmod a+rx tags_gen.sh toe.
<code>
#!/bin/sh

tmp_tag=tags_file
tmp_tag2=tags_file2

echo " "
echo " "
echo " "
echo " "
echo " "
echo "Genereer tags voor ...."
while :
do
	echo "    Voer de bestandsextensie in waarvoor je tags wilt genereren."
	echo -n "  Bestandsextensie zou iets moeten zijn als sh, js, ksh, enz... : "
	read ans

	if [ "$ans" == "" ]; then
		echo " "
		echo "Onjuiste invoer. Probeer opnieuw!"
	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
</code>
</p>
</sect1>


<sect1><heading>Debugger gdb</heading>
<p>
Je zou samen met Vi uitgebreid gebruik moeten maken van gdb.
Debuggen is het belangrijkste aspect van programmeren
aangezien de belangrijkste kosten van een softwareproject in het debuggen
en testen gaan zitten.
</p>
<p>
Gebruik de too 'gdb' voor het debuggen van C++/C programma's. Zie
<bf>'man gdb'</bf>.
Je moet je programma's met de optie -g3 compileren als
<tscreen><verb>
	gcc -g3 foo.c foo_another.c sample.c
</verb></tscreen>

Voor het eenvoudig instellen van aliassen -
<tscreen><verb>
  Stel een alias in in je ~/.bash_profile
  	alias gdb='gdb -directory=/home/src -directory=/usr/myname/src '
  Give -
  	gdb foo.cpp
	gdb> dir /hom2/another_src
	Dit zal aan het bestandszoekpad worden toegevoegd
	gdb> break 'some_class::func<TAB><TAB>
  Hiermee zal de functienaam worden aangevuld om je tijd te sparen bij het typen... en zal uitvoer produceren als -
  	gdb> break 'some_class::function_foo_some_where(int aa, float bb)'
</verb></tscreen>

Het tweemaal indrukken van de TAB-toets is de voltooi&iuml;ng van de
opdrachtregel, wat je heel veel tijd zal besparen bij het typen.
Dit is &eacute;&eacute;n van de belangrijkste technieken bij het gebruik van
gdb.

Voor online hulp -
<tscreen><verb>
	gdb> help
  Geeft online hulp
	gdb> help breakpoints
  Geeft meer details over breakpoints.
</verb></tscreen>

Het instellen van breakpoints en het debuggen
<tscreen><verb>
	unixprompt> gdb exe_filename 
	gdb> b main
Hiermee zal een breakpoint in de main() functie worden geplaatst
	gdb> b 123
Hiermee zal een breakpoint in regel 123 van het huidige bestand worden geplaatst.
	gdb> help breakpoints
Geeft meer details over breakpoints.
</verb></tscreen>

Voor het analyseren van de core dumps 
<tscreen><verb>
	unixprompt> gdb exe_filename  core
	gdb> bt
  Geeft backtrace van functies en regelnummers waar het programma in gebreke bleef
	gdb> help backtrace
  Geeft meer details over backtrace.
</verb></tscreen>
</p>
<p>
Je kunt ook de GUI-versie van gdb, genaamd xxgdb gebruiken.
</p>
<p>
Memory leak tools - 
<itemize>
<item> Freeware Electric Fence on linux cd, </item>
<item> Commercial tools Purify <url url="http://www.rational.com"> </item>
<item> Insure++ <url url="http://www.insure.com"></item>
</itemize>
</p>
</sect1>
</sect>

<sect><heading>Online VIM help</heading>
<p>
Zie de online man pages. Typ achter de unix shell-prompt <bf>man vim</bf> en 
<bf>man gvim</bf>.

Of in de gvim sessie tik je :help in voor de helppagina. Zie ook de
<ref id="Vim Tutorial">Vim Tutiorial.

<tscreen><verb>
			VIM - hoofd helpbestand

     Manoeuvreren:  Gebruik de cursortoetsen, of "h" om naar links te gaan,
		    "j" om naar beneden te gaan, "k" om naar boven te gaan,
		    "l" om naar rechts te gaan.
		    ":1" ga naar 1e regel van pagina
		    ":n" ga naar de n-de regel van pagina
		    "<SHIFT>g" ga naar de onderkant van pagina
		    ":/eenwoord/ zoek naar "eenwoord" in doc

Sluit dit venster:  Gebruik ":q<Enter>".

Ga naar onderwerp:  Positioneer de cursor op een tag tussen |<tag>| en druk op
                    CTRL-].

      Met de muis:  ":set mouse=a" om de muis te activeren (in xterm of GUI).
		    Dubbelklik met de linkermuisknop op een tag tussen |<tag>|.

	 ga terug:  Typ CTRL-T of CTRL-O.

  Specifieke hulp:  Het is mogelijk direct naar een bepaald hulponderwerp
                    te gaan, door een argument aan de ":help" opdracht
		    |:help| op te geven.
		    Het is mogelijk de context verder te specificeren:
			  WAT			ERVOOR     VOORBEELD	~
		    Normale modus opdrachten    (niets)    :help x
		    Visual modus opdrachten	  v_	   :help v_u
		    Insert modus opdrachten	  i_	   :help i_<Esc>
		    command-line opdrachten	  :	   :help :quit
		    command-line editing	  c_	   :help c_<Del>
		    Vim opdrachtargumenten	  -	   :help -r
		    opties			  '	   :help 'textwidth'

lijst met documentatie-bestanden:

|howto.txt|	hoe het meest algemene te doen
|intro.txt|	introductie Vim
|index.txt|	alfabetische index voor iedere mode
|autocmd.txt|	automatisch uitvoeren van opdrachten bij een actie
|change.txt|	verwijderen en vervangen van tekst
</verb></tscreen>
</p>
</sect>


<sect><heading>Vim Home page en Vim links</heading>
<p>
De homepage van vim is te vinden bij <url url="http://www.vim.org"> 
en de mirror-site in de US <url url="http://www.us.vim.org"> 

Vim FAQ is bij <url url="http://www.grafnetix.com/~laurent/vim/faq.html">
en bij <url url="http://www.vim.org/faq">

Eli's Vim Page op <url url="http://www.netusa.net/~eli/src/vim.html">

De Vi Lovers Home Page <url url="http://www.cs.vu.nl/~tmgil/vi.html">

Vim Reference Guide op <url url="http://scisun.sci.ccny.cuny.edu/~olrcc/vim/">

Vim mailing list op <url url="http://www.findmail.com/listsaver/vimannounce.html">
en <url url="http://www.vim.org/mail.html">

Mailing list archieven worden bewaard op: 
<itemize>
<item> <url url="http://www.egroups.com/group/vim"></item>
<item> <url url="http://www.egroups.com/group/vimdev"></item>
<item> <url url="http://www.egroups.com/group/vimannounce"></item>
</itemize>

Vim macro's <url url="http://www.grafnetix.com/~laurent/vim/macros.html">
</p>
</sect>


<sect><heading>Vim Tutorial <label id="Vim Tutorial"></heading>
<sect1><heading>Vim Hands-on Tutorial <label id="vimhandson"></heading>
<p>
Kijk voor de tutorial op een Linux-systeem in /usr/doc/vim-common-5.*/tutor, 
ga onder andere unix-systemen naar de directory waarin vim is ge&iuml;nstalleerd
en zoek naar de doc directory.
<code>
	bash$ cd /usr/doc/vim-common*/tutor
	bash$ less README.txt
	bash$ cp tutor $HOME
	bash$ cd $HOME
	bash$ less tutor
</code>
</p>
</sect1>

<sect1><heading>Vi Tutorials op het Internet<label id="vimurls">
</heading>
<p>
<itemize>
<item> Purdue University <url url="http://ecn.www.ecn.purdue.edu/ECN/Documents/VI/"></item>
<item> 
Quick Vi tutorial <url url="http://linuxwww.db.erau.edu/LUG/node165.html">
</item>
<item> Advanced Vi tutorial <url url="http://www.yggdrasil.com/bible/bible-src/user-alpha-4/guide/node171.html">
</item>
<item> Tutorials <url url="http://www.cfm.brown.edu/Unixhelp/vi_.html">
</item>
<item> 
Tutorials <url url="http://www.linuxbox.com/~taylor/4ltrwrd/section3_4.html">
</item>
<item> Unix world online vi tutorial <url url="http://www.networkcomputing.com/unixworld/unixhome.html">
</item>
<item> 
Univ of Hawaii tutorial <url url="http://www.eng.hawaii.edu/Tutor/vi.html">
</item>
<item> InfoBound  <url url="http://www.infobound.com/vi.html">
</item>
<item> Cornell Univ <url url="http://www.tc.cornell.edu/Edu/Tutor/Basics/vi/">
</item>
<item> Vi Lovers home page: <url url="http://www.cs.vu.nl/~tmgil/vi.html">
</item>
<item> Zal na Sept 2000, verplaatst worden naar <url url="http://www.thomer.com/thomer/vi/vi.html">
</item>
<item> Beginner's Guide to vi <url url="http://www.cs.umr.edu/unixinfo/general/packages/viguide.html">
</item>
<item> vi Help file <url url="http://www.vmunix.com/~gabor/vi.html">
</item>
<item> vim FAQ <url url="http://www.math.fu-berlin.de/~guckes/vim/faq/">
Er bestaan vele Vi Tutorials op het internet. 
Tik bij Yahoo (Lycos, excite of Hotbot) 
 "Vi Tutorial" in het zoekveld en de zoekmachine zal vele verwijzingen 
 retourneren.
</item>
</itemize>
</p>
</sect1>
</sect>


<sect><heading>Vi Tutorial <label id="vimtut"></heading>
<p>
In deze tutorial beschrijven we een aantal "gevorderde" <bf>vi</bf> 
concepten en opdrachten, zodat je de kracht van <bf>vi</bf> 
kunt leren waarderen en dus beslissen hoe je je kennis van 
<bf>vi</bf> opdrachten kunt uitbreiden. 
Bijna alle <bf>vi</bf> referenties sommen de beschikbare opdrachten op,
maar veel gaan er niet op in hoe de opdrachten 
met elkaar in verband staan; dit onderwerp is het hoofddoel van deze tutorial.
</p>


<sect1><heading>Cursor verplaatsingsopdrachten</heading>
<p>
De <bf>vi</bf> cursorverplaatsingsopdrachten maken het mogelijk de
cursor met een minimum aantal toetsaanslagen effici&euml;nt in het bestand
en/of op het scherm te positioneren.
Er zijn heel veel cursorverplaatsingsopdrachten - probeer ze niet allemaal
tegelijkertijd te onthouden!
Later zullen we zien dat veel van de kracht van <bf>vi</bf> 
komt door het mixen van cursorverplaatsingsopdrachten met andere opdrachten
om tekst te verwijderen, wijzigen, yanken (kopiren), en filteren.

Wijzig alsjeblieft een groot tekstbestand (zoals bijvoorbeeld <bf>wknight</bf>)
zodat je met iedere opdracht kunt experimenteren op 't moment dat 't wordt
beschreven. Houd in gedachten dat deze opdrachten alleen in de Commando-modus
werken, niet in de Insert Modus; als je "opdrachten" in je tekst krijgt, druk
dan op de ESC-toets om naar de Commando-modus terug te keren.

<itemize>
<item> <bf>cursortoetsen</bf> : Zoals we hebben gezien, kunnen we met
de cursorpijlen een enkel teken naar links, beneden, boven en rechts
opschuiven. Verplaatsing voorbij de bovenkant, de
onderkant, rechts van het einde van een regel, of links van het begin van
een regel van het bestand is niet toegestaan (geen regelomslag).</item>

<item> <bf>hjkl</bf> : Toen <bf>vi</bf> werd geschreven (rond 1978), hadden
veel terminals op UNIX-systemen geen cursortoetsen!
<bf>h, j, k,</bf> en <bf>l</bf> werden gekozen als opdrachten
om respectievelijk naar links, beneden, boven, en naar rechts te gaan.
Probeer ze uit! De meeste <bf>vi</bf> fanaten geven de voorkeur aan deze
cursortoetsen omdat
<itemize>
<item><bf>(a)</bf> ze op alle toetsenborden op dezelfde plaats voorkomen, en
</item>
<item><bf>(b)</bf> ze prettig onder de vingers passen, in tegenstelling tot
de meeste cursortoetsen, die in een box of "T" of 
&eacute;&eacute;n of andere niet lineaire vorm zijn gearrangeerd.
</item>
</itemize>

Waarom h, j, k, en l? In de ASCII character set, staat CTRL-H voor de
backspace (verplaatsing naar links), CTRL-J voor linefeed (verplaatsing naar
beneden), en, k en l bevinden zich direct naast h en j, dus zoals je kunt
zien zijn ze makkelijk te onthouden.
</item>
<item> <bf>0</bf> : ("nul", niet "oh") Ga naar het begin van de huidige
regel. (gebruik de cursortoetsen of <bf>h j k l</bf> om naar een
ingesprongen tekstregel met een paar "e" tekens erin te gaan, om dit en
de volgende paar opdrachten uit te proberen.
Als je geen ingesprongen regel in je bestand kunt vinden, maak er dan 
&eacute;&eacute;n aan door een paar spaties aan het begin van een regel
in te voegen).</item>

<item> <bf> ^ </bf> : Ga naar het eerste niet-blanco teken van de huidige
regel. (Voor een ingesprongen regel, hebben 0 en ^ een verschillende 
betekenis).
</item>

<item> <bf> $ </bf> : Ga naar het laatste teken van de huidige regel.
</item>

<item> <bf> tC </bf> : Ga naar (vlak ervoor) het volgende teken c in
de huidige regel. (Druk op 0, en tik dan `te' in.
Hiermee zal naar de eerste `e' in de huidige regel worden gegaan).
</item>

<item> <bf> fC </bf> : Zoek naar (plaatst cursor onder teken) volgende 
teken `c' in de huidige regel. (Tik `fe' in, en de cursor zal de volgende
`e' vinden - dat wil zeggen, verplaatst worden naar - de volgende `e' in de 
huidige regel).
</item>

<item> <bf> TC </bf> : Ga naar (direct erachter) het vorige teken c
in de huidige regel (Druk op $, dan Te).</item>

<item> <bf> FC </bf> : Zoek (plaatst cursor onder teken) het vorige teken c
in de huidige regel. (Druk op Fe.)</item>

<item> <bf> n| </bf> : Ga naar kolom n in de huidige regel. 
(Probeer 20 |. De cijfers 2 en 0 zullen, als je ze intikt, niet worden 
getoond, maar als je de | intikt, zal de cursor naar kolom 20 gaan).

Probeer wat met t f T F | te experimenteren. Als je iets niet goed doet, zal
<bf>vi</bf> een beep genereren.
</item>
<item> <bf> w </bf> : Voorwaarts naar het begin van het volgende "kleine"
woord (een "klein" woord bestaat uit een onafgebroken reeks alfanumerieke
tekens of leestekens, maar niet gemengd alfanumeriek en leestekens). Probeer
een aantal keren de w - merk op wat er gebeurt bij een leesteken.
</item>

<item> <bf> W </bf> : Voorwaarts naar het begin van het volgende "grote"
woord (gemengd alfanumeriek en leestekens). Probeer een aantal dozijn maal
de W.</item>

<item> <bf> b </bf> : Terugwaarts naar het begin van een "klein" woord.
</item>

<item> <bf> B </bf> : Terugwaarts naar het begin van een "groot" woord.
</item>

<item> <bf> e </bf> : Voorwaarts naar het einde van een "klein" woord.
</item>

<item> <bf> E </bf> : Voorwaarts naar het einde van een "groot" woord.
</item>

<item> <bf> + Return </bf> : Ga naar het eerste niet-blanco teken op de
volgende regel. (+ en de Return toets hebben hetzelfde effect).
</item>

<item> <bf> - </bf> : Ga naar het eerste niet-blanco teken op de vorige regel.
</item>

<item> <bf> ) </bf> : Ga naar het einde van de zin. (Een zin eindigt of met
een lege regel of met een punt of een uitroepteken gevolgd door twee
spaties of op het einde van een regel.
Een punt of uitroepteken gevolgd door een spatie betekent niet het einde
van een zin; dit gedrag is juist, overeenkomstig traditionele regels van hoe
zinnen in getypte documenten zouden moeten verschijnen, maar lijkt vaak
onjuist voor degenen die nooit typeles hebben gehad).
</item>

<item> <bf> ( </bf> : Ga naar het begin van de zin.
</item>

<item> <bf> } </bf> : Ga naar het einde van de paragraaf. 
(Paragrafen worden gescheiden door lege regels, volgens de definitie van
<bf>vi</bf>).
</item>

<item> <bf> { </bf> : Ga naar het begin van de paragraaf.
</item>

<item> <bf> H </bf> : Ga naar de home-positie (bovenste regel) op het scherm.
</item>

<item> <bf> M </bf> : Ga naar de middelste regel op het scherm.
</item>

<item> <bf> L </bf> : Ga naar de laatste regel op het scherm.
</item>

<item> <bf> nG </bf> : Ga naar regel n. Als n niet wordt opgegeven, ga
dan naar de laatste regel in het bestand.
(Probeer bijvoorbeeld 15G om naar regel 15 te gaan. De CTRL-G opdracht toont
de naam van het bestand, wat statusinformatie en het huidige regelnummer.
Om naar het begin van het bestand te gaan: 1G)
</item>

<item> <bf> CTRL-d </bf> : Scroll een half scherm omlaag (zie noot).</item>
<item> <bf> CTRL-u </bf> : Scroll een half scherm omhoog (zie noot).</item>
<item> <bf> CTRL-f </bf> : Ga een scherm verder (zie noot).</item>
<item> <bf> CTRL-b </bf> : Ga een scherm terug (zie noot).</item>
<item> <bf> Noot </bf> : Deze vier scrolling/paging opdrachten kunnen niet met
de verwijder-, wijzigings-, kopieer- of filteropdrachten worden gebruikt.
</item>

<item> <bf> /reg_exp </bf> : Ga naar het volgende voorkomen van de
reguliere expressie reg_exp.
Als je de / intikt, wordt de cursor naar de linkeronderkant van het scherm
geplaatst en wacht totdat je de reguliere expressie typt.
Druk op de Return toets om de invoer te bevestigen; <bf>vi</bf> zoekt dan
in voorwaartse richting naar het volgende voorkomen van de reguliere
expressie. 
Bijvoorbeeld, tik in /de gevolgd door een druk op de Return. Hiermee wordt
naar het volgende voorkomen van `de' gegaan, misschien onderdeel uitmakend
van een wat langer woord (ander, weder, enz.). Als je de / intikt,
gevolgd door de Return, zoekt <bf>vi</bf> naar de laatst opgegeven reguliere
expressie waarnaar werd gezocht.</item>

<item> <bf> n </bf> : Heeft hetzelfde effect als het indrukken van de /
en de Return; d.w.z., zoekt naar het volgende voorkomen van de laatste 
reguliere expressie waarnaar je zocht.</item>

<item> <bf> ?reg_exp </bf> : Zoek voorwaarts, in plaats van terugwaarts. Als
er geen reg_exp werd opgegeven, zoekt het naar de laatste reguliere expressie
die werd ingevoerd. Het zoeken met / en ? "na" de onderkant en "voor" de 
bovenkant van het bestand is toegestaan.</item>

<item> <bf> N </bf> : Hetzelfde als het indrukken van ? en dan op Return.
</item>
</itemize>
</p>
</sect1>


<sect1><heading>Herhalingen</heading>
<p>
Veel van de verplaatsingsopdrachten die hiervoor werden besproken kunnen
worden voorafgegaan door een getal waarmee wordt aangegeven hoeveel maal
de erna volgende opdracht moet worden herhaald; de verplaatsing wordt
gewoon het gegeven aantal malen herhaald:
<itemize>
<item> <bf> 3w </bf> : Ga drie woorden vooruit</item>
<item> <bf> 5k </bf> : Ga vier tekens naar boven</item>
<item> <bf> 3fa </bf> : Zoek de derde opeenvolgende a in de huidige regel</item> 
<item> <bf> 6+ </bf> : Ga zes regels naar beneden</item>
</itemize>
Voor een aantal opdrachten hebben de herhalingen een speciale betekenis:
<itemize>
<item> <bf> 4H </bf> : Ga naar regel 4 op het scherm (home plus 3)</item>
<item> <bf> 8L </bf> : Ga naar de achtste regel vanaf de onderkant van het
scherm.</item>
<item> <bf> 3$ </bf> : Ga naar het einde van de derde regel van onder
</item>
</itemize>
Bij een aantal opdrachten (b.v., ^) wordt de herhaling genegeerd; 
bij anderen (b.v., / en ? ) is het niet toegestaan
</p>
</sect1>



<sect1><heading>Verwijderen van Tekst</heading>
<p>
We hebben gezien dat <bf>dd</bf> de huidige regel verwijdert. Dit kan met
een herhaling worden gebruikt: 3dd verwijdert drie regels, de huidige
regel en de 2 daarop volgende regels. 

De d opdracht kan als een "voorvoegsel" worden gebruikt met de meeste
verplaatsingsopdrachten hierboven om bijna willekeurige stukken tekst te
verwijderen. De verplaatsingsopdrachten worden "target specifiers" genoemd,
als ze in combinatie met d worden gebruikt. Aan d kan een herhaling worden
opgegeven. (Als je hiermee gaat experimenteren, denk er dan aan na iedere
opdracht de u in te tikken om de verwijdering ongedaan te maken).

<itemize>
<item> <bf> dw </bf> : Verwijder "klein" woord voorwaarts</item>
<item> <bf> d3w </bf> : Verwijder drie "kleine" woorden voorwaarts</item>
<item> <bf> 3dw </bf> : Drie keer, verwijder "klein" woord voorwaarts</item>
<item> <bf> 3d3w </bf> : Drie keer, verwijder drie "kleine" woorden voorwaarts
(dat wil zeggen, verwijder negen "kleine" woorden voorwaarts)</item>
<item> <bf> d+ </bf> : Verwijder huidige en daaropvolgende regel</item>
<item> <bf> d/de </bf>: Verwijder vanaf het huidige teken tot aan, maar niet
inclusief het volgende voorkomen van het patroon 'de'</item>
<item> <bf> d$ </bf> : Verwijder tot aan het einde van de regel</item>
<item> <bf> d0 </bf> : Verwijder tot aan het begin van de regel</item>
<item> <bf> d30G </bf> : Verwijder vanaf de huidige regel tot en met
regel 30</item>
<item> <bf> dG </bf> : Verwijder vanaf de huidige regel tot en met
de laatste regel</item>
<item> <bf> d1G </bf> : Verwijder vanaf de huidige regel tot en met
regel 1</item>
</itemize>
Gebruik x om enkele tekens te verwijderen. aan x kan een herhaling worden
opgegeven:
<itemize>
<item> <bf> 15x </bf> : Verwijder het huidige en de 14 daaropvolgende
14 tekens</item>
</itemize>
x is in feite gewoon een afkorting van d1; dat wil zeggen, verwijder 
&eacute;&eacute;n teken rechts.
</p>
</sect1>


<sect1><heading>Wijzigen van Tekst</heading>
<p>
De c opdracht is vergelijkbaar met d, behalve dat het <bf>vi</bf> naar Insert
mode laat schakelen, waarbij het mogelijk wordt de oorspronkelijke (ongewenste)
tekst in iets anders te veranderen.

Plaats bijvoorbeeld de cursor aan het begin van een woord (druk op w om
naar het begin van het volgende woord te gaan). Druk dan op cw om dat woord
te wijzigen. Op het scherm zal het laatste teken in het woord dat wordt
gewijzigd, worden vervangen door een <bf>$</bf>-symbool om de grens van
de wijziging aan te geven; typ een nieuw woord in (je zult het oorspronkelijke
woord op het scherm overschrijven) en druk de ESC-toets in als je klaar bent.
Wat je invoert mag langer of korter zijn dan het woord dat wordt gewijzigd.

Plaats de cursor aan het begin van een regel bestaande uit op z'n minst
drie woorden, en probeer c3w om drie woorden te wijzigen.
Probeer c$ om tot het einde van de huidige regel te wijzigen.
In alle gevallen wordt de grens aangegeven met $ daar waar de wijziging
alleen effect heeft op de huidige regel.

Als een wijziging op meer dan alleen de huidige regel effect heeft,
verwijdert <bf>vi</bf> de oorspronkelijke tekst van het scherm en schakelt
over naar Insert-mode. Probeer bijvoorbeeld eens met c3+ de huidige
en 3 volgende regels te wijzigen;
<bf>vi</bf> verwijdert de vier oorspronkelijke regels van het scherm en
schakelt over naar Insert-mode op een nieuwe blanco regel.
Druk zoals gewoonlijk op de ESC-toets wanneer je klaar bent met het invoeren
van je nieuwe tekst.

Een aantal andere wijzigingsopdrachten:
<itemize>
<item> <bf> cc </bf> : Wijzig huidige regel</item>
<item> <bf> 5cc </bf> : Wijzig vijf regels (huidige en de volgende vier)</item>
<item> <bf> c/de </bf> : Wijzig vanaf huidige teken tot aan, maar niet
inclusief het volgende voorkomen van het volgende patroon dat voldoet aan
'de'</item>
<item> <bf> c$ </bf> : Wijzig tot aan het einde van de regel</item>
<item> <bf> c30G </bf> : Wijzig vanaf de huidige regel tot en met Regel 30
</item>
<item> <bf> cG </bf> : Wijzig vanaf de huidige regel tot en met de laatste
regel</item>
<item> <bf> c1G </bf> : Wijzig vanaf de huidige regel tot en met Regel 1
</item>
</itemize>
</p>
</sect1>


<sect1><heading>Yanken (kopi&euml;ren) van Tekst</heading>
<p>
De y opdracht kopieert een kopie van tekst naar een buffer; de gekopieerde
tekst kan dan met p of P elders in het bestand worden geplaatst (of geplakt).

De eenvoudigste vorm van yank is yy om de huidige regel te kopi&euml;ren;
probeer na een yy een kopie van de gekopieerde regel na de cursor te
plaatsen. Na een yy, kun je zoveel kopie&euml;n van de gekopieerde regel
maken als je wilt door naar boven en naar beneden in het bestand te gaan
en op p te drukken.

Probeer voor het kopi&euml;ren van meerdere regels bijvoorbeeld 5yy
(kopieer de huidige en de volgende vier regels).
p plaatst een kopie van de gekopieerde regels na de cursor; de reeks 5yyp
"werkt" maar het is waarschijnlijk niet wat je wilt. De P opdracht is
vergelijkbaar met p, maar het plaatst een kopie van de gekopieerde tekst
voor de cursor; probeer de reeks 5yyP.

Andere kopieer-opdrachten:
<itemize>
<item> <bf> y3w </bf> : Kopieer drie woorden</item>
<item> <bf> y$ </bf> :  Kopieer tot aan het einde van de huidige regel</item>
<item> <bf> y1G </bf> : Kopieer vanaf de huidige regel tot en met Regel 1</item>
</itemize>
</p>
</sect1>


<sect1><heading>Filteren van tekst</heading>
<p>
De filteropdracht <bf>!</bf>, verwacht de naam van een UNIX-opdracht
(wat een filter zou moeten zijn), en geeft de geselecteerde regels dan door
aan het filter, waarbij de geselecteerde regels in de <bf>vi</bf>-buffer
dan worden vervangen door de uitvoer van het filteropdracht.
<bf>vi</bf>'s vermogen om bijna willekeurige stukken tekst via iedere 
UNIX-filter door te geven voegt, zonder "extra kosten" aan <bf>vi</bf> een
ongelofelijke flexibliteit toe.

Ter illustratie zal een aantal voorbeelden van hulp zijn. Maak in het
bestand een regel met slechts het woord 'who' en absoluut geen andere tekst.
Plaats de cursor op deze regel, en druk op <bf>!!</bf>.
Deze opdracht is analoog aan dd, cc, of yy, maar in plaats van het verwijderen,
wijzigen of kopi&euml;ren van de huidige regel, filtert het de huidige regel.
Als je de tweede ! indrukt, gaat de cursor naar de linkerhoek aan de onderkant
van het scherm en wordt een enkele ! getoond, daarbij wachtend totdat je de
naam van een filter opgeeft. Typ als filternaam sh en druk op de Return-toets.
<bf>sh</bf> (de Bourne shell) is een filter!
Het leest van standaarinvoer, verwerkt zijn invoer (dat wil zeggen, voert
opdrachten uit) en stuurt de uitvoer (de uitvoer van die opdrachten) naar
standaarduitvoer. Het filteren van de regel met who via sh zorgt ervoor dat de
regel met who wordt vervangen door een lijst met de huidige gebruikers op het
systeem - direct in je bestand!

Probeer dit proces te herhalen met <bf>date</bf>. Dat wil zeggen, maak een
regel met niets anders dan het woord <bf>date</bf>, plaats de cursor dan op
deze regel, druk op <bf>!!sh</bf> en de Return-toets. De regel met
<bf>date</bf> wordt vervangen door de uitvoer van de <bf>date</bf> opdracht.

Plaats de cursor op de eerste regel van de uitvoer van who. Tel het aantal
regels. Stel bijvoorbeeld dat het aantal zes is. Selecteer dan deze zes
regels om via sort te laten filteren; druk op 
<bf>6!!sort</bf> en vervolgens de Return-toets. De zes regels zullen aan sort
worden doorgegeven, en de zes oorspronkelijke regels worden door de uitvoer
van sort vervangen.

De filteropdracht kan alleen op gehele regels worden toegepast, niet op
tekens of woorden. 

Nog wat andere filter-opdrachten (hier betekent, &lt CR &gt een druk op de
Return-toets):
<itemize>
<item> <bf>!/de &lt CR &gt sort &lt CR &gt</bf> : Sorteer vanaf de huidige
regel tot en met de volgende regel met daarin het woord `de'.
</item>
<item><bf> !1Ggrep de &lt CR &gt</bf> : Vervang vanaf de huidige regel tot
en met Regel 1 door slechts die regels met daarin het woord `de'.
</item>
<item><bf> !Gawk '{print $1}' &lt CR &gt </bf>: Vanaf de huidige regel tot
aan het einde van het bestand, het vervangen van iedere regel door slechts
het eerste woord.
</item>
</itemize>
</p>
</sect1>



<sect1><heading>Markeren van Regels en Tekens</heading>
<p>
Je kunt regels en tekens markeren om te worden gebruikt als doel voor
verplaatsing, verwijdering, wijziging, ze te kopi&euml;ren, of filteren met
behulp van de opdracht mc, waar c staat voor een kleine letter.

Plaats de cursor bijvoorbeeld in het midden van een woord en druk op ma.
Hiermee wordt het teken onder de cursor met a gemarkeerd.

Verplaats de cursor nu naar elders, weg van het gemarkeerde teken en naar
een andere regel (gebruik de cursorpijlen, CTRL-u of iets dergelijks).
Om naar de gemarkeerde regel terug te keren, tik je 'a in.
(dat wil zeggen, een enkel aanhalingsteken en dan een a).
Hierdoor wordt de cursor naar het eerste niet-blanco teken in de regel 
gemarkeerd met a verplaatst.

Ga weer weg van deze regel. Druk op `a (dat wil zeggen, een aanhalingsteken
achterwaarts en dan een a) om naar het gemarkeerde teken terug te keren.
Hierdoor wordt de cursor naar het teken gemarkeerd met a verplaatst.

Markeringen worden meestal gebruikt in combinatie met verwijderingen,
wijzigingen, kopieer- of filteropdrachten.
Verplaats de cursor bijvoorbeeld naar een andere regel dan die met de
markering a en druk dan op d'a (d, een enkel aanhalingsteken en een a).
Hiermee wordt de huidige regel tot en met de regel gemarkeerd met a verwijderd.

Plaats de cursor in het midden van een ander woord en druk op mb om de
markering b in te stellen. Verplaats de cursor nu, weg van dat woord (maar
slechts een paar regels, zodat je makkelijk kunt zien wat we aan het doen zijn),
en druk dan op d`b (d, aanhalingsteken achterwaarts, b).
Hierdoor wordt het huidige teken tot en met het teken gemarkeerd met b
verwijderd.

Een ander voorbeeld is om de uitvoer van who te sorteren, markeer de eerste
regel (ma), verplaats de cursor dan naar de laatste regel en druk op
!'asort en dan de Return-toets.

Als je naar een markering springt en besluit terug te gaan naar waar je vandaan
sprong, kun je '' intikken (ga terug naar regel ..) of `` (ga terug naar het
teken ..).
</p>
</sect1>


<sect1><heading>Benoemen van Buffers</heading>
<p>
Als je tekst verwijdert, wijzigt of kopieert, wordt de oorspronkelijke tekst
(tot de volgende verwijdering, wijziging of kopieeropdracht) in een 
onbenoemde buffer opgeslagen van waaruit het kan worden opgehaald met
p of P. Door gebruik te maken van de onbenoemde buffer, kan alleen de meest
recente verwijderde, gewijzigde of gekopieerde tekst worden hersteld.

Als je meerdere delen van je tekst wilt verwijderen, wijzigen of kopi&euml;ren
en je wilt ze allemaal onthouden (tot aan een maximum van 26), kun je 
voor de wijzigings- of kopieeropdracht aan een buffer een naam toekennen.
De naam van een buffer heeft de vorm "c (dubbel aanhalingsteken, kleine letter
c).

Tik bijvoorbeeld "ayy in om de huidige regel naar buffer a te kopi&euml;ren.
Verplaats je vervolgens naar een andere regel en druk op "byy om die regel naar
buffer b te kopi&euml;ren. Verplaats de cursor nu naar elders in het bestand en
tik in "ap en "bp om kopie&euml;n van de tekst te plaatsen die in de buffers
a en b zijn geplaatst.

Nog wat andere benoemde bufferopdrachten:
<itemize>
<item> <bf> "a6yy </bf> : Kopieer zes regels (de huidige en de volgende
vijf) naar buffer a</item>
<item> <bf> "bd1G </bf> : Verwijder vanaf de huidige regel tot en met Regel 1,
waarbij de verwijderde regel in buffer b wordt opgeslagen</item>
<item> <bf> "cy'c </bf> : Kopieer vanaf de huidige regel gemarkeerd als c
naar buffer c (markeringen en buffers zijn verschillend, en kunnen dezelfde
naam hebben zonder dat <bf>vi</bf> daarvan in de war raakt).</item>
</itemize>
</p>
</sect1>


<sect1><heading>Substituties</heading>
<p>
Gebruik de :s opdracht om een stuk tekst door een ander stuk tekst in regels
door je hele bestand te vervangen.
Wat substitueer voorbeelden:
<itemize>
<item> <bf> :1,$s/de/DE/g </bf>Vervang van regel 1 tot aan de laatste
regel (regel $), het woord `de' door `DE'
doe dit globaal in iedere regel waar `de' voorkomt</item>
<item> <bf> :'a,.s/.*/ha ha/ </bf> Vervang in de regel gemarkeerd met `a'
tot aan de huidige regel (regel .) alles op de regel door de tekst `ha ha'
</item>
</itemize>
</p>
</sect1>


<sect1><heading>Diverse "Commando's beginnend met een dubbele punt"
</heading>
<p>
Alle volgende opdrachten beginnen met een dubbele punt; als je de dubbele
punt intikt, gaat de cursor naar de linkeronderkant van het scherm en wordt
er een prompt, bestaande uit een dubbele punt, weergegeven, die wacht totdat
je gereed bent met het invoeren van je opdracht.

Een aantal belangrijke voorbeelden:
<itemize>
<item><bf>:w </bf> Schrijf de inhoud van de buffer naar het bestand zonder
<bf>vi</bf> te verlaten</item>

<item><bf>:w abc </bf>Schrijf de inhoud van de buffer naar het bestand 
`abc' (waarbij `abc' wordt aangemaakt als het niet bestaat of de huidige
inhoud overschrijft als het wel bestaat) zonder <bf>vi</bf> te verlaten
</item>

<item><bf>:1,10w  abc  </bf>Schrijf de regels 1 tot en met 10 naar het
bestand `abc'</item>

<item><bf>:'a,$w abc  </bf>Schrijf vanaf de regel gemarkeerd als a tot aan
de laatste regel naar het bestand `abc'</item>

<item><bf>:e abc </bf>Wijzig bestand `abc', in plaats van het huidige
bestand. <bf>vi</bf> drukt een foutmelding af als er aan het huidige bestand
wijzigingen zijn aangebracht die nog niet met :w zijn opgeslagen
</item>

<item><bf>:e! abc </bf>Wijzig het bestand `abc', waarbij eventuele wijzigingen
die zijn aangebracht aan het huidige bestand worden verworpen</item>

<item><bf>:e #  </bf>Wijzig het vorige gewijzigde bestand (opeenvolgende
:e# opdrachten schakelen tussen twee bestanden)</item>

<item><bf>:f abc  </bf>Wijzig de bestandsnaam voor de huidige <bf>vi</bf>
buffer in abc</item>
<item><bf>:q </bf>Be&euml;indig, tenzij niet opgeslagen wijzigingen zijn
gemaakt</item>
<item><bf>:q! </bf>Be&euml;indig, waarbij eventuele wijzingingen die zijn
aangebracht, worden verworpen</item>
<item><bf>:r abc </bf>Lees het bestand `abc' in de huidige <bf>vi</bf> buffer,
na de regel waarop de cursor staat (probeer :r croc om een kopie van het
croc bestand in te lezen)</item>
<item><bf>:!cmd </bf>Voer de opdracht cmd uit (who, sort, ls, enz.)
</item>
</itemize>
</p>
</sect1>


<sect1><heading>Opties Instellen</heading>
<p>
Diverse opties hebben effect op de "feel" van <bf>vi</bf>. 
Je kunt alle diverse opties die kunnen worden ingesteld tonen met de
opdracht :set all. Je kunt set ook gebruiken om opties te wijzigen.

Als je bijvoorbeeld regelnummers wilt zien voor de regel in het bestand
wat je aan het wijzigen bent, gebruik je de opdracht :set number.
Voor het uitzetten van de regelnummering, gebruik je de opdracht
:set nonumber. De meeste opties kunnen worden afgekort. :set nu zet de
regelnummering aan en :set nonu zet de regelnummering uit.

Met een :set nomagic, wordt de speciale betekenis van de reguliere expressie
tekens (punt, asterisk, blokhaak, enz.) uitgeschakeld. Gebruik :set magic
om de speciale betekenissen weer te herstellen.

Een aantal opties verwacht een waarde. :set tabstop=4 bijvoorbeeld 
zorgt ervoor dat tabs als vier spatie-tekens worden weergegeven in plaats
van de gebruikelijke acht.

Als je bemerkt dat je bepaalde opties altijd op een bepaalde manier instelt, kun
je de set opdrachten die je wilt in een bestand met de naam .exrc plaatsen,
of je kunt de omgevingsvariabele EXINIT instellen om de gewenste opties in
te stellen.

Als je login-shell bijvoorbeeld de Bourne-shell is, zou deze regel in je
.profile bestand geplaatst kunnen worden:
<code>
	EXINIT='set nomagic nu tabstop=4'; export EXINIT
</code>
Als je login-shell een C-shell is, zou deze regel in je .login bestand
geplaatst kunnen worden:
<code>
	setenv EXINIT 'set nomagic nu tabstop=4'
</code>
</p>
</sect1>


<sect1><heading>Key Mappings</heading>
<p>
Als je bemerkt dat je keer op keer een serie eenvoudige opdrachten aanroept,
kun je met de opdracht :map de serie opdrachten aan een ongebruikte
opdrachttoets toekennen. Als in de toekenning controle-tekens zoals de
Return-toets (CTRL-M in ASCII) of de ESC (CTRL-[ in ASCII), moeten worden
opgenomen, laat dergelijke tekens dan voorafgaan door een CTRL-v om hun
speciale betekenis te onderdrukken.

In bijvoorbeeld de hierna volgende opdracht wordt aan de opdracht
CTRL-A toegekend dat de cursor 55 regels verder wordt geplaatst, dan weer
terug wordt gegaan naar de regel met de minste tekens, waarbij die blanco
regel wordt gewijzigd in een formfeed (CTRL-L) gevolgd door drie blanco
regels. Dat wil zeggen dat iedere CTRL-A de volgende pagina zal pagineren,
zonder dat paragrafen op meerdere pagina's worden gesplitst.

Noot: In deze opdracht wordt ieder controle-teken getoond als ^C, C is hierbij
een hoofdletter. CTRL-M wordt bijvoorbeeld getoond als ^M.
Wanneer je deze opdracht invoert, zul je ook de CTRL-v tekens zoals getoond,
niet zien: iedere CTRL-v onderdrukt louter de gebruikelijke speciale betekenis
van het volgende controle-teken, dus als je de reeks ^V^M intikt, zul je
op het scherm slechts ^M zien. In deze opdracht, is ^M de Return-toets en
^[ is de ESC-toets.
<code>
	:map ^A  55+?^$^V^Mcc^V^L^V^M^V^M^V^M^V^[
</code>
</p>
</sect1>


<sect1><heading>Wijzigen van Meerdere Bestanden</heading>
<p>
Je kunt met <bf>vi</bf> meerdere bestanden wijzigen, door als argumenten op
de opdrachtregel, meerdere bestandsnamen op te geven:
<code>
	vi croc fatherw  wknight
</code>
Twee opdrachten beginnend met een dubbele punt worden gebruikt om je
tussen de meerdere bestanden te verplaatsen:
<itemize>
<item><bf> :n  </bf>Ga naar het volgende bestand in de argumentenlijst 
(je moet je wijzigingen opslaan met
:w anders zal <bf>vi</bf> een foutmelding weergeven)
</item>
<item><bf> :rew </bf>Ga terug en ga weer verder met het eerste bestand
in de lijst met argumenten</item>
</itemize>
De :n en :rew opdrachten zijn wat onhandig, maar er zijn een aantal
belangrijke voordelen: de inhoud van benoemde buffers
("a, "b, "c, etc.) worden door de bestanden heen onthouden, dus je kunt
:n en :rew met p en P gebruiken om tekst heen en weer tussen bestanden 
te kopi&euml;ren. Ook wordt de meest recente zoekstring voor de / en ?
opdrachten door de bestanden heen onthouden, dus je kunt nogal makkelijk 
herhalende zoekopdrachten in meerdere bestanden gebruiken.

Probeer bijvoorbeeld het volgende experiment:
Ga eerst uit <bf>vi</bf>, start <bf>vi</bf> dan op met croc en wknight 
als argumenten:
<code>
	$ vi croc wknight
</code>
Zoek in croc naar `de'

<bf>	/de &lt CR &gt </bf>

Kopieer deze regel naar buffer a:

<bf>	"ayy </bf>

Ga nu naar het volgende bestand (je hebt geen wijzigingen aangebracht aan
croc, dus dit werkt):

<bf>	:n &lt CR &gt </bf>

Zoek naar de volgende regel met `de', zonder het opnieuw intikken van de
zoekstring:

<bf>	n </bf>

Plaats een kopie van buffer a na de huidige regel in wknight:

<bf>	"ap </bf>

Ga twee regels naar beneden, en kopieer de huidige regel naar buffer b:

<bf>	jj"byy </bf>

Sla de wijzigingen in wknight op

<bf>	:w &lt CR &gt </bf>

Ga nu terug naar croc

<bf>	:rew &lt CR &gt </bf>

Zoek nogmaals, en plaats een kopie van buffer b na de gevonden regel:

<bf>	n"bp </bf>

Sla de wijzigingen op en be&euml;indig <bf>vi</bf>

<bf>	ZZ </bf>
</p>
</sect1>


<sect1><heading>Laatste Opmerkingen</heading>
<p>
Deze tutorial was bedoeld om wat van de mogelijkheden van 
<bf>vi</bf> te introduceren waar je in het systeemhandboek van <bf>vi</bf> 
misschien overheen zou kijken of die wellicht niet in het handboek worden
vermeld (op de verschillende systemen zijn de handboeken van zeer 
verschillende kwaliteit).

Je zult na het lezen van deze tutorial geen <bf>vi</bf>-expert zijn, maar je
kunt de mogelijkheden van <bf>vi</bf> dan wel juist inschatten. 
Slechts tijd en moeite kunnen een <bf>vi</bf>-expert van je
maken. Maar de effici&euml;ntie en alomvattenheid betalen dit op de lange
termijn terug.

Mogelijk heb je besloten dat je <bf>vi</bf> haat. Het zij zo! 
Maar wees je er bewust van dat <bf>vi</bf> de standaard UNIX teksteditor
blijft - de enige editor waar je op kunt rekenen dat het op ieder UNIX-systeem
beschikbaar is - dus zelfs als je de voorkeur geeft om dagelijks iets anders
te gebruiken, wordt je geadviseerd om bekend te zijn met het absolute
minimum aan het <bf>vi</bf>-materiaal dat in deze tutorial is behandeld.
</p>
</sect1>
</sect>

<sect><heading>Vim Referentiekaart<label id="vimref"></heading>
<sect1><heading>Vi status</heading>
<p>
Vi heeft 3 modi:
<enum>
<item> <bf><it>opdrachtenmodus</it></bf> - Normale en initi&euml;le status;
anderen keren hier naar terug (gebruik <bf>ESC</bf> om een gedeeltelijk
getypte opdracht af te breken)</item>
<item> <bf><it>invoer modus</it></bf> - ingegaan door specieke opdrachten
<bf>a i A I o O c C s S R </bf> en be&euml;indigd door <bf>ESC</bf> of
abnormaal door een interrupt</item>
<item> <bf><it>regel modus</it></bf> - d.w.z. het wachten op invoer
na een <bf>: </bf>, <bf>/ </bf>, <bf>? </bf> of een <bf>! </bf> 
opdracht (be&euml;indigd met <bf>CR</bf>, af te breken met <bf>CTRL-c</bf>).
<bf>CTRL</bf> is de control-toets: <bf>CTRL-c</bf> betekent "control c"
</item>
</enum>
</p>
</sect1>


<sect1><heading>Shell Commando's</heading>
<p>
<enum>
<item> <bf>TERM=</bf> <it>code</it> Plaatst een code-naam voor je terminal
in de variabele <bf>TERM</bf></item>
<item> <bf>export TERM</bf> Draagt de waarde van <bf>TERM</bf> over (de 
terminal code) naar ieder UNIX-systeemprogramma dat terminal afhankelijk is.
</item>
<item> <bf>tput init</bf> Initialiseert de terminal zodat het juist zal
functioneren met diverse UNIX-systeemprogramma's.</item>
<item> <bf>vi </bf> <it>filename</it> Geeft toegang tot de schermeditor
<bf>vi</bf> zodat je een specifiek bestand kunt wijzigen.</item>
<item> <bf>vi </bf> <it>file1 file2 file3</it> Laadt drie bestanden in de
<bf>vi</bf> buffer om te worden gewijzigd. Die bestanden zijn 
<it>file1, file2,</it> en <it>file3</it>.</item>
<item> <bf>view </bf> <it>file</it> Roep de vi-editor aan met het bestand
<it>file</it> in read-only modus</item>
<item> <bf>vi -R </bf> <it>file</it> Roep de vi-editor aan met het bestand
<it>file</it> in read-only mode</item>
<item> <bf>vi -r </bf> <it>file</it> Herstel het bestand <it>file</it> en
recente wijzigingen na een systeemcrash</item>
<item> <bf>vi -r </bf> <it>file</it> Herstel het bestand <it>file</it> en 
recente wijzigingen na een systeemcrash</item>
</enum>
</p>
</sect1>


<sect1><heading>Opties Instellen</heading>
<p>
<enum>
<item> <bf>:set</bf> <it>optie</it> Activeer <it>optie</it></item>
<item> <bf>:set</bf> <it>optie=waarde</it> Wijs <it>waarde</it> toe aan
<it>optie</it></item>
<item> <bf>:set no</bf> <it>optie</it> Deactiveer <it>optie</it></item>
<item> <bf>:set </bf> Toon door gebruiker ingestelde opties</item>
<item> <bf>:set all</bf> Toon lijst met alle huidige opties, zowel
standaard als die zijn ingesteld door de gebruiker</item>
<item> <bf>:set </bf> <it>optie</it>? Toon waarden van <it>optie</it>
</item>
</enum>
</p>
</sect1>


<sect1><heading>Gebruikte Notaties</heading>
<p>
Notaties:
<enum>
<item> <bf>CTRL-c</bf> <bf>CTRL</bf> is de control-toets: <bf>CTRL-c</bf> betekent "control c"
</item>
<item> <bf>CR</bf> is een Carriage return (ENTER toets)</item>
</enum>
</p>
</sect1>

<sect1><heading>Onderbreken, annuleren</heading>
<p>
<itemize>
<item> <bf>ESC</bf> be&euml;indig invoeg-modus of onvolledige opdracht</item>
<item> <bf>CTRL-?</bf> <bf>CTRL</bf> is de control-toets: 
<bf>CTRL-?</bf> betekent "control ?" verwijder of rubout interrupts</item>
<item> <bf>CTRL-l</bf> reprint/ververs scherm als CTRL-? het door de war gooit
</item>
</itemize>
</p>
</sect1>



<sect1><heading>Bestandsmanipulatie</heading>
<p>
<itemize>
<item> <bf>ZZ</bf> Bewaar bestand en be&euml;indig vi</item>
<item> <bf>:wq</bf> Bewaar het bestand en be&euml;indig vi</item>
<item> <bf>:w</bf> Sla het huidige bestand op</item>
<item> <bf>:w!</bf> Forceer schrijven naar het huidige bestand, als het
bestand alleen lezen is</item>
<item> <bf>:w<it>name</it></bf> Schrijf naar bestand <it>name</it></item>
<item> <bf>:q</bf> Be&euml;indig vi</item>
<item> <bf>:q!</bf> Forceer be&euml;indiging vi (verwerp wijzigingen)</item>
<item> <bf>:e name</bf> Wijzig bestands<it>naam</it></item>
<item> <bf>:e!</bf> opnieuw wijzigen, verwerp veranderingen</item>
<item> <bf>:e + name</bf> wijzig bestand <it>name</it>, beginnend aan het eind
</item>
<item> <bf>:e + n</bf> begin met wijzigen op regel<it>n</it></item>
<item> <bf>:e #</bf> wijzig andere bestand</item>
<item> <bf>:n</bf> wijzig volgende bestand in <it>arglist</it></item>
<item> <bf>:args</bf> geef lijst met bestanden in huidige bestandenlijst
</item>
<item> <bf>:rew</bf> wijzig eerste bestand in bestandenlijst</item>
<item> <bf>:n args</bf> specificeer nieuwe arglist</item>
<item> <bf>:f </bf> toon huidige bestand en regel</item>
<item> <bf>CTRL-G</bf> synoniem voor :f , toon huidige bestand en regel
</item>
<item> <bf>:ta tag </bf> naar tag file entry <it>tag</it></item>
<item> <bf>CTRL-] </bf> :ta, volgende woord is tag</item>
</itemize>
</p>
</sect1>


<sect1><heading>Verplaatsen</heading>
<p>
<itemize>
<item> <bf>Cursorpijlen</bf> Verplaats de cursor</item>
<item> <bf>CTRL-d</bf> Scroll halve pagina omlaag</item>
<item> <bf>CTRL-u</bf> Scroll halve pagina omhoog</item>
<item> <bf>CTRL-f</bf> Scroll een volledige pagina omlaag</item>
<item> <bf>CTRL-b</bf> Scroll een volledige pagina omhoog</item>
<item> <bf>:0</bf> Ga naar begin van het bestand</item>
<item> <bf>:n</bf> Ga naar regelnummer n</item>
<item> <bf>:$</bf> Ga naar einde bestand </item>
<item> <bf>0</bf> Ga naar begin van de regel</item>
<item> <bf>^</bf> Ga naar eerste niet-blanco teken</item>
<item> <bf>$</bf> Ga naar einde regel</item>
<item> <bf>CR</bf> Ga naar het begin van de volgende regel</item>
<item> <bf>-</bf> Ga naar het begin van de vorige regel</item>
<item> <bf>%</bf> Zoek naar overeenkomende blokhaak</item>
<item> <bf>G </bf> ga naar regel (standaard de laatste regel)</item>
<item> <bf>&rsqb&rsqb </bf> volgende sectie/functie</item>
<item> <bf>&lsqb&lsqb </bf> vorige sectie/functie</item>
</itemize>
</p>
</sect1>


<sect1><heading>Regel positionering</heading>
<p>
<itemize>
<item> <bf>H </bf> Linksbovenaan venster</item>
<item> <bf>L </bf> Laatste regel van venster</item>
<item> <bf>M </bf> Middelste regel van venster</item>
<item> <bf>+ </bf> Volgende regel, naar eerst niet-blanco</item>
<item> <bf>- </bf> Vorige regel, naar eerste niet-blanco</item>
<item> <bf>CR </bf> return, zelfde als +</item>
<item> <bf>j </bf> volgende regel, zelfde kolom</item>
<item> <bf>k </bf> vorige regel, zelfde kolom</item>
</itemize>
</p>
</sect1>

<sect1><heading>Positioneren van de cursor</heading>
<p>
<itemize>
<item> <bf>0 </bf> begin van de regel</item>
<item> <bf>$ </bf> einde van de regel</item>
<item> <bf>h </bf> vooruit </item>
<item> <bf>l </bf> terug </item>
<item> <bf>SPACE </bf> zelfde als l </item>
<item> <bf>fx </bf> zoek x voorwaarts</item>
<item> <bf>Fx </bf> zoek x terugwaarts</item>
<item> <bf>; </bf> herhaal laatste f F</item>
<item> <bf>, </bf> inverse van ;</item>
<item> <bf>| </bf> naar aangegeven kolom</item>
<item> <bf>% </bf> zoek overeenkomende { of }</item>
</itemize>
</p>
</sect1>

<sect1><heading>Woorden, zinnen, paragrafen</heading>
<p>
<itemize>
<item> <bf>w </bf> Woord vooruit</item>
<item> <bf>b </bf> Woord achteruit</item>
<item> <bf>e </bf> Einde woord</item>
<item> <bf>) </bf> Naar volgende zin </item>
<item> <bf>( </bf> Zin terug </item>
<item> <bf>} </bf> Naar volgende paragraaf </item>
<item> <bf>{ </bf> Paragraaf terug </item>
<item> <bf>W </bf> Volgende woord</item>
<item> <bf>B </bf> W terug</item>
<item> <bf>E </bf> Naar einde van W</item>
</itemize>
</p>
</sect1>


<sect1><heading>Markeren en terugkeren</heading>
<p>
<itemize>
<item> <bf>``</bf> (druk tweemaal op de ` toets) Vorige context</item>
<item> <bf>''</bf> (druk tweemaal op de ` toets) 
Vorige context op eerste niet-blanco teken in regel</item>
<item> <bf>mx</bf> Markeer positie met letter x</item>
<item> <bf>`x</bf> (` en letter x) ga naar markering x</item>
<item> <bf>'x</bf> ga naar markering x op eerste niet-blanco teken in regel
</item>
</itemize>
</p>
</sect1>




<sect1><heading>Correcties tijdens het invoegen</heading>
<p>
<itemize>
<item> <bf>CTRL-h</bf> Verwijder laatste teken</item>
<item> <bf>CTRL-w</bf> Verwijder laatste woord</item>
<item> <bf>erase </bf> Druk op de DELETE toets, zelfde als CTRL-h</item>
<item> <bf>kill </bf> Je kill-toets, verwijder invoer deze regel</item>
<item> <bf>\ </bf> Escapes CTRL-h, DELETE en kill</item>
<item> <bf>ESC </bf> Be&euml;indig het invoegen, terug naar opdrachtenmodus
</item>
<item> <bf>CTRL-? </bf> Interrupt, be&euml;indig invoer</item>
<item> <bf>CTRL-d </bf> Terugtab over <it>autoindent</it></item>
<item> <bf>CTRL-v </bf> Quote niet-afdrukbaar teken</item>
</itemize>
</p>
</sect1>


<sect1><heading>Aanpassen van het scherm</heading>
<p>
<itemize>
<item> <bf>CTRL-l</bf> Maak het scherm schoon en bouw het opnieuw op</item>
<item> <bf>CTRL-r</bf> typ opnieuw, elimineer @lines</item>
<item> <bf>z-CR</bf> ververs scherm, huidige regel bovenkant van venster
</item>
<item> <bf>z-</bf> ververs scherm, huidige regel onderkant van venster
</item>
<item> <bf>z.</bf> ververs scherm, huidige regel in het midden van het venster
</item>
<item> <bf>/pat/z-</bf> <it>pat</it> regel onderaan</item>
<item> <bf>tn</bf> Gebruik n regel venster</item>
<item> <bf>CTRL-e</bf> Scroll venster 1 regel naar beneden</item>
<item> <bf>CTRL-y</bf> Scroll venster 1 regel naar boven</item>
</itemize>
</p>
</sect1>


<sect1><heading>Verwijderen</heading>
<p>
<itemize>
<item> <bf>x</bf> Verwijder het teken onder de cursor</item>
<item> <bf>X</bf> Verwijder het teken voor de cursor</item>
<item> <bf>D</bf> Verwijder tot aan het einde van de regel</item>
<item> <bf>d^</bf> Verwijder terug tot aan het begin van de regel</item>
<item> <bf>dd</bf> Verwijder de huidige regel</item>
<item> <bf>ndd</bf> Verwijder <it>n</it> regel te beginnen met de huidige regel
</item>
<item> <bf>dnw</bf> Verwijder <it>n</it> woorden te beginnen vanaf de cursor
</item>
</itemize>
</p>
</sect1>


<sect1><heading>Invoegen, wijzigen</heading>
<p>
<itemize>
<item> <bf>i</bf> Ga naar invoermode en voeg in voor de cursor</item>
<item> <bf>I</bf> Ga naar invoermode en voeg in voor het eerste niet-blanco
teken</item>
<item> <bf>a</bf> Ga naar invoermode en voeg in na de cursor</item>
<item> <bf>A</bf> Ga naar invoermode en voeg in na het einde van de regel
</item>
<item> <bf>o</bf> Voeg een nieuwe regel in na de regel onder de huidige
regel en ga naar invoermode</item>
<item> <bf>O</bf> Voeg een nieuwe regel in boven de huidige regel en
gan naar invoermode</item>
<item> <bf>r</bf> Vervang het teken onder de cursor (ga NIET naar invoermode)
</item>
<item> <bf>R</bf> Ga naar invoermode en vervang tekens</item>
<item> <bf>C</bf> shift-c. Wijzig rest van regel</item>
<item> <bf>D</bf> shift-d. Verwijder rest van regel</item>
<item> <bf>s</bf> Vervang tekens</item>
<item> <bf>S</bf> Vervang regels</item>
<item> <bf>J</bf> Voeg regels samen</item>
<item> <bf>J</bf> Voeg regels samen</item>
</itemize>
</p>
</sect1>


<sect1><heading>Kopi&euml;ren en Plakken</heading>
<p>
De "yank buffer" wordt met <it>IEDERE</it> delete opdracht gevuld, of expliciet
door <bf>Y</bf> en <bf>yy</bf>.
<itemize>
<item> <bf>Y</bf> Kopieer de huidige regel naar de yank buffer</item>
<item> <bf><it>n</it>yy</bf> Kopieer <it>n</it> regels te beginnen vanaf
de huidige regel naar de yank buffer</item>
<item> <bf>p</bf> "Plak" de inhoud van de yank buffer na de cursor
(of onder de huidige regel)</item>
<item> <bf>P</bf> "Plak" de yank buffer voor de cursor (of boven
de huidige regel)</item>
<item> <bf>"<it>x</it>p </bf> "Plak" vanuit buffer x</item>
<item> <bf>"<it>x</it>y </bf> Yank (kopieer) naar buffer x</item>
<item> <bf>"<it>x</it>d </bf> Verplaats naar buffer x</item>
</itemize>
</p>
</sect1>


<sect1><heading>Operators (gebruik dubbel om effect te hebben op regels)
</heading>
<p>
<itemize>
<item> <bf>d </bf> delete (verwijder)</item>
<item> <bf>c </bf> change (wijzig)</item>
<item> <bf>< </bf> linker verschuiving</item>
<item> <bf>> </bf> rechter verschuiving</item>
<item> <bf>! </bf> filter door opdracht</item>
<item> <bf>= </bf> inspringing voor LISP</item>
<item> <bf>y </bf> yank (kopieer) tekst naar buffer</item>
</itemize>
</p>
</sect1>


<sect1><heading>Zoeken en vervangen</heading>
<p>
<itemize>
<item> <bf>/<it>text</it></bf> Zoek voorwaarts naar <it>text</it></item>
<item> <bf>?<it>text</it></bf> Zoek terugwaarts naar <it>text</it></item>
<item> <bf>n</bf> Herhaal de laatste zoekactie in dezelfde richting</item>
<item> <bf>N</bf> Herhaal de laatste zoekactie in tegengestelde richting</item>
<item> <bf>/</bf> Herhaal de laatste zoekactie voorwaarts</item>
<item> <bf>?</bf> Herhaal de laatste zoekactie terugwaarts</item>
<item> <bf>&lsqb addr &rsqb s/van/naar/ &lsqb g &rsqb </bf> Zoek naar het
voorkomen van <it>van</it>
en vervang het in de huidige regel of in de range <bf><it>addr</it></bf>
(twee regelnummers gescheiden door een komma; 1,$ is het gehele bestand) 
door <bf><it>naar</it></bf>.
Vervang &eacute;&eacute;n voorkomen per regel, of alle voorkomendheden
als <bf><it>g</it></bf> is gespecificeerd.
Bijvoorbeeld, :3,20s/zoekwoord/anderwoord/g  zal "zoekwoord" vervangen
door "anderwoord" te beginnen bij regel 3 tot aan regel 20. 'g' voor globaal
betekent dat alle keren dat het "zoekwoord" voorkomt, het moet worden vervangen.
</item>
</itemize>
</p>
</sect1>




<sect1><heading>Algemeen</heading>
<p>
<itemize>
<item> <bf>:sh</bf> Roept een shell aan (kan worden be&euml;indigd met CTRL-d)
</item>
<item> <bf>:!<it>opdracht</it></bf> Roept een shell aan om de 
<it>opdracht</it> uit te voeren.
</item>
<item> <bf>:set number</bf> Schakel regelnummering in
</item>
<item> <bf>:set nonumber</bf> Schakel regelnummering uit
</item>
</itemize>
</p>
</sect1>



<sect1><heading>Regeleditor-opdrachten</heading>
<p>
<itemize>
<item> <bf>:</bf> Vertelt <bf>vi</bf> dat de volgende opdrachten die je
uitvoert, regeleditor-opdrachten zullen zijn.</item>
<item> <bf>:sh</bf> Ga tijdelijk naar de shell om een aantal shell-opdrachten
uit te voeren zonder <bf>vi</bf> te verlaten.</item>
<item> <bf>CTRL-d</bf> Be&euml;indig de tijdelijke shell en keer terug naar
<bf>vi</bf> zodat je het huidige venster kunt wijzigen.</item>
<item> <bf>:</bf><it>n</it> Ga naar de <it>n</it>-de regel in de buffer.
</item>
<item> <bf>:</bf><it>x,z</it><bf>w</bf> <it>filename</it> Schrijf regel vanaf
het nummer <it>x</it> tot aan het nummer <it>z</it> naar het nieuwe bestand
genaamd <it>filename</it>.</item>
<item> <bf>:$</bf> Verplaats de cursor naar het begin van de laatste
regel in de buffer.</item>
<item> <bf>:.,$d</bf> Verwijder alle regels vanaf de huidige regel tot aan
de laatste regel.</item>
<item> <bf>:r</bf> <it>filename</it> Voegt de inhoud van het bestand 
<it>filename</it> toe onder de huidige regel van de buffer.</item>
<item> <bf>:s</bf><it>/text/new_text/</it> Vervangt het eerste voorkomen van
<it>text</it> op de huidige regel door <it>new_text</it></item>
<item> <bf>:s</bf><it>/text/new_text/g</it> Vervangt ieder voorkomen van
<it>text</it> op de huidige regel door <it>new_text</it></item>
<item> <bf>:g</bf><it>/text/s//new_text/g</it> Wijzigt ieder voorkomen van
<it>text</it> in de buffer naar <it>new_text</it>.</item>
</itemize>
</p>
</sect1>



<sect1><heading> Andere opdrachten</heading>
<p>
<itemize>
<item> <bf>u</bf> Maak de laatste wijziging ongedaan</item>
<item> <bf>U</bf> Herstel de huidige regel</item>
<item> <bf>&tilde</bf> Wijzig grote letter in kleine letter en vice versa
</item>
<item> <bf>J</bf> Voeg de huidige regel samen met de volgende regel</item>
<item> <bf>.</bf> Herhaal laatste tekstwijzigingsopdracht</item>
<item> <bf>CTRL-g</bf> Toon bestandsnaam en regelnummer</item>
</itemize>
</p>
</sect1>
</sect>

<sect><heading>Gerelateerde URL's</heading>
<p>
Aan VIM gerelateerde URL's zijn te vinden bij -
<itemize>
<item> C and C++ Beautifer <url url="http://www.metalab.unc.edu/LDP/HOWTO/C-C++Beautifier-HOWTO.html"></item>
<item> Linux goodies <url url="http://www.aldev.8m.com"> or bij <url url="http://www.aldev.webjump.com"></item>
</itemize>
</p>
</sect>


<sect><heading>Andere Formaten van dit Document</heading>
<p>
Dit document is in 10 verschillende formaten gepubliceerd, te weten - 
DVI, Postscript, Latex, LyX, GNU-info, HTML, RTF(Rich Text Format), 
Plain-text, Unix man pages en SGML.
<itemize>
<item>
Je kunt dit HOWTO-document als een enkel tar-archief ophalen in HTML, DVI, 
Postscript of SGML-formaat vanaf -
<url url="ftp://metalab.unc.edu/pub/Linux/docs/HOWTO/other-formats/">
 of 
<url url="ftp://metalab.unc.edu/pub/Linux/docs/HOWTO/other-formats/">
</item>

<item>Plain tekstformaat is in: 
<url url="ftp://metalab.unc.edu/pub/Linux/docs/HOWTO">
of 
<url url="ftp://metalab.unc.edu/pub/Linux/docs/HOWTO">
</item>

<item>Vertalingen naar 't Frans, Duits, Spaans, Chinees, Japans staan in
<url url="ftp://metalab.unc.edu/pub/Linux/docs/HOWTO">
of <url url="ftp://metalab.unc.edu/pub/Linux/docs/HOWTO">
Alle hulp bij het vertalen naar andere talen is welkom.
</item>
</itemize>
Het document is geschreven door gebruik te maken van een tool genaamd
"SGML tool" welke kan worden opgehaald vanaf - 
<url url="http://www.xs4all.nl/~cg/sgmltools/">
Bij het compileren van de source krijg je met de volgende opdrachten

<itemize>
<item>sgml2html vim-howto.sgml     (een html-bestand)</item>
<item>sgml2rtf  vim-howto.sgml     (een RTF-bestand)</item>
<item>sgml2latex vim-howto.sgml    (een latex-bestand)</item>
</itemize>

Dit document is te vinden op -
<itemize>
<item> <url url="http://metalab.unc.edu/LDP/HOWTO/Vim-HOWTO.html"></item>
</itemize>

Je kunt dit document ook vinden op de volgende mirror-sites -
<itemize>
<item> <url url="http://www.caldera.com/LDP/HOWTO/Vim-HOWTO.html">
</item>
<item> <url url="http://www.WGS.com/LDP/HOWTO/Vim-HOWTO.html">
</item>
<item> <url url="http://www.cc.gatech.edu/linux/LDP/HOWTO/Vim-HOWTO.html">
</item>
<item> <url url="http://www.redhat.com/linux-info/ldp/HOWTO/Vim-HOWTO.html">
</item>
<item> Andere mirror-sites in de buurt (netwerk-adres-wijsheid) zijn te
vinden op <url url="http://metalab.unc.edu/LDP/hmirrors.html">
selecteer een site en ga naar de directory /LDP/HOWTO/Vim-HOWTO.html
</item>
</itemize>


Gebruik het xdvi-programma om dit document in het dvi-formaat te bekijken.
Het xdvi-programma is te vinden in het
tetex-xdvi*.rpm package in Redhat Linux wat kan worden gevonden via de
ControlPanel | Applications | Publishing | TeX menu buttons.
<tscreen><verb>
	Geef de volgende opdracht om het dvi-document te lezen -
		xdvi -geometry 80x90 howto.dvi
	En pas de grootte van het scherm met de muis aan. 
	Zie de manpage over xdvi. 
	Gebruik de pijltjestoetsen, Page Up, Page Down keys, om door
	het document te manoeuvreren, je kunt ook de
	'f', 'd', 'u', 'c', 'l', 'r', 'p', 'n' letter
	toetsen gebruiken om naar boven, onder, het midden, de volgende
	pagina, vorige pagina, enz te gaan.
	Druk op 'x' om het expert-menu uit te schakelen.
</verb></tscreen>
Je kunt het postscript-bestand lezen met behulp van het programma 'gv' 
(ghostview) of 'ghostscript'.
Het ghostscript programma is te vinden in het ghostscript*.rpm package en
het gv programma is te vinden in het gv*.rpm package in Redhat Linux
welke kan worden gelokaliseerd via de ControlPanel | Applications | Graphics 
menu buttons. Het gv programma is veel gebruikersvriendelijker dan ghostscript.
Ghostscript en gv zijn ook voor andere platformen beschikbaar zoals OS/2,
Windows 95 en NT.
<tscreen><verb>
	Geef de volgende opdracht om het postscript document te lezen -
		gv howto.ps

	Met gebruik van ghostscript geef je op -
		ghostscript howto.ps
</verb></tscreen>

Je kunt het HTML-formaat document lezen met Netscape Navigator, Microsoft
Internet explorer, Redhat Baron Web browser of enige andere webbrowsers.

Je kunt de latex, LyX uitvoer lezen met LyX een "X-Windows" front end naar
latex.
</p>
</sect>

<sect><heading>Copyright Notice</heading>
<p>
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 than you should 
intimate all the authors of this document.
</p>
</sect>
</article>
</linuxdoc>