VI Help

Een handleiding voor VI

Last updated: Tue Jul 19 15:11:23 2005


Index


Inleiding

Dit document is gebaseerd op een textfile die ik op het net vond. Het is een vrij complete handleiding van VI, de VIsual editor, aanwezig op vrijwel ieder serieus UNIX-platform. VI werd ontworpen om de toen bestaande line-editors op te volgen, omdat terminals met beeldschermen in gebruik werden genomen, als vervanging van teletypes e.d.
VI is gebaseerd op de line-editor EX, waarvan ook vrijwel alle commando's over genomen zijn. Dit zijn de commando's die met een ':' beginnen.

Het belangrijkste wat je moet weten als beginner is dat VI twee hoofdmodes heeft, nl. een edit mode en een command/move mode. Als je VI opstart kom je automatisch in de command mode terecht. Door een tekstbewerkingscommando uit te voeren kom je in de edit mode. Om weer terug in command mode te komen volstaat het indrukken van <esc>. Als je niet meer weet in welke mode je je bevindt, druk je dus gewoon op <esc> en je zit weer in de command mode. De <esc> is hiermee een van de meest gebruikte toetsen in VI. Je kunt overigens ook zeggen dat men na het typen van ':' in de command mode in een aparte, derde mode terechtkomt, nl. in de line-edit mode.

Er bestaan veel varianten van VI, maar die ondersteunen over het algemeen alle commando's die 'standaard' VI heeft. Varianten zijn bijvoorbeeld Elvis en Vim. In deze twee varianten is het bijvoorbeeld ook mogelijk de pijltjes-toetsen te gebruiken, zelfs tijdens het editen, zodat je minder vaak tussen de edit en de command/move mode heen en weer hoeft te schakelen. Pas hier echter mee op; controleer altijd even met ^L in de command mode, of er niet allemaal ANSI-codes door de tekst heen komen te staan. En ook al lijkt hij het goed te doen, deze optie is niet altijd even betrouwbaar. Verder heeft vim de mogelijkheid om macro's op te nemen m.b.v. qq in command mode.


Legenda

default-waarde     : 1
<*> : `*' moet niet letterlijk genomen worden
[*] : `*' is optioneel
^X : <ctrl>X
<sp> : spatie
<cr> : carriage return
<lf> : linefeed
<ht> : horizontal tab
<esc> : escape
<erase> : jouw `erase' karakter
<kill> : jouw `kill' karakter
<intr> : jouw `interrupt' karakter
<a-z> : een element in de reeks
N : aantal
`*' = toegestaan
`-' = niet van toepassing
CHAR : char ongelijk <ht>|<sp>
WOORD : woord gevolgd door <ht>|<sp>|<lf>
Terug naar de Index

Move commando's

 N | Commando         | Betekenis
---+------------------+--------------------------------------------------
* | h | ^H | <erase> | <*> chars naar links.
* | j | <lf> | ^N | <*> regels omlaag.
* | l | <sp> | <*> chars naar rechts.
* | k | ^P | <*> regels omhoog.
* | $ | Naar einde regel <*> vanaf de cursor.
- | ^ | Naar eerste CHAR van de regel.
* | _ | Naar eerste CHAR <*> - 1 regels lager.
* | - | Naar eerste CHAR <*> regels hoger.
* | + | <cr> | Naar eerste CHAR <*> regels lager.
- | 0 | Naar eerste char van de regel.
* | | | Naar kolom <*> (<ht>: alleen naar het eindpunt).
* | f<char> | <*> <char>'s naar rechts (`find').
* | t<char> | Tot voor <*> <char>'s naar rechts.
* | F<char> | <*> <char>'s naar links.
* | T<char> | Tot na <*> <char>'s naar links.
* | ; | Herhaal vorige `f'|`t'|`F'|`T' <*> keer.
* | , | Idem in tegenovergestelde richting.
* | w | <*> woorden vooruit.
* | W | <*> WOORDEN vooruit.
* | b | <*> woorden terug (`back').
* | B | <*> WOORDEN terug.
* | e | Naar einde woord <*> vooruit (`end').
* | E | Naar einde WOORD <*> vooruit.
* | G | Naar regel <*> (`goto') (default EOF).
* | H | Naar regel <*> vanaf bovenaan het scherm
| (`home').
* | L | Naar regel <*> vanaf onderaan het scherm
| (`last').
- | M | Naar middelste regel van het scherm.
* | ) | <*> zinnen verder.
* | ( | <*> zinnen terug.
* | } | <*> paragrafen verder.
* | { | <*> paragrafen terug.
- | ]] | Naar de volgende sektie (default EOF).
- | [[ | Naar vorige sektie (default begin van de file).
- | `<a-z> | Naar de markering.
- | '<a-z> | Naar het begin van de regel met de markering.
- | `` | Naar de plaats waar de cursor stond voor
| de laatste absolute sprong (voorbeelden van
| absolute sprongen zijn `/' en `G').
- | '' | Naar het begin van de regel waarop de cursor
| stond voor de laatste absolute sprong.
- | /<string> | Naar volgende <string>.
- | ?<string> | Naar vorige <string>.
- | n | Herhaal vorige `/'|`?' (`next').
- | N | Idem in tegenovergestelde richting.
- | % | Zoek het volgende haakje en ga naar het
| bijbehorende haakje (ook bij `{'|`}' en
| `['|`]').
Terug naar de Index

Zoeken (zie hierboven)

:ta <naam>              | Kijk in de `tags'-file[s] waar <naam> wordt gedefinieerd (file, regel) en ga daarheen.
^] | Gebruik de naam onder de cursor in een `:ta'- commando.
^T | Haal de vorige `tag' van de `tagstack' en ga naar de bijbehorende positie.
:[x,y]g/<string>/<cmd> | Zoek globaal [van regel x tot en met y] naar <string> en doe telkens het `ex'-commando <cmd>.
:[x,y]v/<string>/<cmd> | Doe <cmd> op de niet-geselekteerde regels.
Terug naar de Index

Veranderingen ongedaan maken

u          | Maak de laatste verandering ongedaan (`undo').
U | Maak alle veranderingen op een regel ongedaan, zolang de cursor nog op die regel staat (helaas).
:q! | Verlaat vi zonder te schrijven.
:e! | Edit de file opnieuw.
Terug naar de Index

Tekst toevoegen (afsluiten met <esc>)

 * | a               | <*> keer na de cursor (`append').
* | A | <*> keer aan het einde van de regel.
* | i | <*> keer voor de cursor (`insert').
* | I | <*> keer voor de eerste CHAR van de regel.
* | o | Open een nieuwe regel onder de huidige (de count
| is alleen nuttig op een langzame terminal).
* | O | Open een nieuwe regel boven de huidige (de count
| is alleen nuttig op een langzame terminal).
* | ><move> | Schuif de regels beschreven door <*><move>
| een `shiftwidth' naar rechts.
* | >> | Schuif <*> regels een `shiftwidth' naar rechts.
* | ["<a-zA-Z1-9>]p | Zet de inhoud van de (default undo-) buffer <*>
| keer rechts van de cursor (`put'). Een buffer
| die regels bevat, wordt slechts 1 keer
| uitgeschreven, onder de huidige regel.
* | ["<a-zA-Z1-9>]P | Zet de inhoud van de (default undo-) buffer <*>
| keer links van de cursor. Een buffer die
| regels bevat, wordt slechts 1 keer
| uitgeschreven, boven de huidige regel.
* | . | Herhaal het laatste commando <*> keer. Als het
| laatste commando voor een `.'-commando
| verwijst naar een genummerde buffer, wordt het
| nummer van de buffer eerst verhoogd (en wordt
| <*> genegeerd). Voorbeelden:
|
| "1pu.u.u.u.u - `loop' door buffers 1
| tot en met 5
| "1P.... - haal ze terug
Terug naar de Index

Tekst weghalen

Alles wat wordt weggehaald kan worden opgeslagen in een buffer. Dit doe je door voor het delete-commando een `"' met daarachter een letter <a-z> te typen. Het weggehaalde bevindt zich dan in de buffer met die letter. Als <A-Z> wordt gebruikt als buffernaam, wordt de bijbehorende buffer in <a-z> uitgebreid i.p.v. overschreven met de tekst. De undo-buffer bevat altijd de laatste verandering. Buffers <1-9> bevatten de laatste 9 REGEL- verwijderingen (`"1' is de recentste).

 * | x        | Verwijder <*> chars onder en na de cursor.
* | X | <*> chars voor de cursor.
* | d<move> | Van begin- tot eindpunt van <*><move>.
* | dd | <*> regels.
- | D | De rest van de regel.
* | <<move> | Schuif de regels beschreven door <*><move>
| een `shiftwidth' naar links.
* | << | Schuif <*> regels een `shiftwidth' naar links.
* | . | Herhaal laatste commando <*> keer.
Terug naar de Index

Tekst veranderen (afsluiten met <esc>)

 * | r<char>             | Vervang <*> chars door <char> (`replace') - geen <esc>.
* | R | Overschrijf de rest van de regel, voeg <*> - 1 keer toe.
* | s | Vervang <*> chars (`substitute').
* | S | <*> regels.
* | c<move> | Van begin- tot eindpunt van <*><move> (`change').
* | cc | <*> regels.
* | C | De rest van de regel en <*> - 1 volgende regels.
* | =<move> | Als de optie `lisp' aan staat, herschikt dit
| commando de regels beschreven door <*><move>
| alsof ze waren ingevoerd met gebruikmaking van
| de optie `ai'.
- | ~ | Verander hoofd- in kleine letters en omgekeerd (zou een operator moeten zijn, zoals `c').
* | J | Sluit <*> regels aaneen (`join') (default 2).
* | . | Herhaal laatste commando <*> keer (`J' 1 keer).
- | & | Herhaal laatste `ex'-substitutie-commando, bijv. `:s/fout/goed'.
- | :[x,y]s/<p>/<r>/<f> | Vervang [op regels x tot en met y] het patroon
| <p> (default het vorige patroon) door <r>.
| Nuttige vlaggen <f> zijn `g' voor `globaal'
| (d.w.z. verander alle niet-overlappende
| voorkomens van <p>) en `c' voor `confirm'
| (typ `y' om een bepaalde substitutie te
| bevestigen, anders <cr>). In plaats van `/'
| kun je elke andere interpunktie-CHAR ongelijk
| <lf> gebruiken als scheider.
Terug naar de Index

Substitutie-patronen

De standaard meta-karakters voor een substitutie-patroon zijn `&' en `~'; ze worden gegeven door `\&' en `\~' als de `magic' optie is uitgezet. Elk voorkomen van `&' wordt vervangen door de karakters die beschreven worden door de reguliere expressie in het commando. Een `~' in het substitutie- patroon wordt vervangen door de tekst van het vorige substitutie-patroon.
Er zijn meer meta-patronen. Het patroon `\n' (met `n' uit [1-9]) wordt vervangen door de tekst beschreven door de n-de reguliere sub-expressie tussen `\(' en `\)'. De patronen `\u' en `\l' converteren het volgende karakter in het substitutie-patroon naar resp. hoofd- en kleine letter als dit karakter een letter is. De patronen `\U' en `\L' laten de conversie voortduren tot een patroon `\E' dan wel `\e' wordt bereikt, anders tot het einde van het substitutie-patroon.

Terug naar de Index


Onthouden van tekst ('yanking')

Bij yank-commando's kun je `"<a-zA-Z>' voor het commando zetten net als bij delete. Je kopieert anders alleen naar de undo-buffer. Het gebruik van buffers <a-z> is DE manier om tekst naar een andere file te kopieren: zie het commando `:e <file>'.

 * | y<move>    | Yank van begin- tot eindpunt van <*><move>.
* | yy | <*> regels.
* | Y | Idem (zou gelijkwaardig met `y$' moeten zijn).
- | m<a-z> | Markeer de cursor positie met een letter.
Terug naar de Index

Commando's tijdens tekstveranderingen

^@            | Als eerste karakter van een toevoeging wordt het
| vervangen door de vorige toevoeging (max. 128
| chars), waarna de toevoeging is be-eindigd.
^V | Ontdoe de volgende char van zijn speciale betekenis, bijv. <esc>.
^D | Schuif een `shiftwidth' naar links.
0^D | Haal alle indentatie weg (er mogen nog geen andere chars op de regel zijn gezet).
^^D | Idem, maar de indentatie is terug op de volgende regel.
^T | Schuif een `shiftwidth' naar rechts.
^W | Schuif een woord terug.
^H | <erase> | Schuif een char terug.
<kill> | Ga naar het begin van de verandering op de huidige regel.
<intr> | Als <esc> (maar je krijgt ook een piep).
Terug naar de Index

Wegschrijven, andere files editen, en exit

In `:' `ex'-commando's kun je de huidige file aangeven met `%',
de alternatieve file met `#' (gewoonlijk de vorige file).
Ook markeringen kunnen gebruikt worden als regelnummers: '<a-z>.
In de commando's `:w'|`:f'|`:cd'|`:e'|`:n' kunnen shell-meta-karakters
gebruikt worden.

:q                      | Verlaat vi, tenzij de buffer veranderd is (`quit').
:q! | Verlaat vi zonder schrijven.
^Z | Stop vi tijdelijk.
:w | Schrijf de file (`write').
:w <naam> | Schrijf naar de file <naam>.
:w >> <naam> | Voeg de buffer toe aan de file <naam>.
:w! <naam> | Overschrijf de file <naam>.
:x,y w <naam> | Schrijf regels x tot en met y naar <naam>.
:wq | Schrijf en verlaat vi; sommige versies voeren
| het `q'-commando uit zelfs als de `w' mislukt
| is! Gebruik liever `ZZ'.
ZZ | Schrijf als de buffer veranderd is en verlaat vi.
| Als je vi hebt opgestart met de `-r' optie, kun
| je de file maar beter ekspliciet wegschrijven
| (`w' of `w!'), of de editor ekspliciet verlaten
| (`q!') als je de file niet wilt overschrijven -
| sommige versies van vi handelen de `recover'
| optie niet helemaal goed af.
:x [<file>] | Idem [maar schrijf naar <file>] (`eXit').
:x! [<file>] | `:w![<file>]' en `:q'.
:pre | Preserve - de buffer wordt bewaard alsof het
| systeem zojuist ge-crashed is; voor
| noodgevallen, als een `:w'-commando mislukt is
| en je niet weet hoe je je werk kunt behouden
| (zie `vi -r').
:f <naam> | Zet de huidige filenaam op <naam>.
:cd [<dir>] | Zet de werk-directory op <dir> (default je home directory).
:cd! [<dir>] | Idem, maar schrijf de huidige buffer niet weg.
:e [+<cmd>] <file> | Edit een andere file zonder vi te verlaten -
| doordat de inhoud van de buffers bewaard blijft
| (op de undo-buffer na), kan zo tekst gekopieerd
| worden. [Doe het `ex'-commando <cmd> (default
| `$') zodra de nieuwe file ingelezen is.]
| <cmd> mag geen <sp> of <ht> bevatten.
| Zie `het starten van vi'.
:e! [+<cmd>] <file> | Idem zonder de huidige buffer weg te schrijven.
^^ | Ga naar de alternatieve (gewoonlijk de vorige)
| file.
:rew | Begin opnieuw bij de eerste file
| (bij `vi file1 file2 ...') (`rewind').
:rew! | Idem zonder de huidige te schrijven.
:n [+<cmd>] [<files>] | Ga naar de volgende file of geef een nieuwe lijst
| argumenten (`next').
:n! [+<cmd>] [<files>] | Idem zonder de huidige buffer weg te schrijven.
:args | Geef de argumenten, met de huidige file tussen
| `[' en `]'.
Terug naar de Index

Display-commando's

^G       | Geef file-naam, status, regelnummer en relatieve positie.
^L | Herschrijf het scherm (soms `^P' of `^R').
^R | Soms vervangt vi een weggegooide regel door een
| `@', weg te halen door `^R' (zie optie `redraw').
[*]^E | Laat <*> volgende regels zien, de cursor blijft
| op de huidige regel (voor zover mogelijk).
[*]^Y | Laat <*> vorige regels zien, de cursor blijft op
| de huidige regel (voor zover mogelijk).
[*]^D | Scroll <*> regels omlaag (`down')
| (default het aantal regels van de vorige
| scroll; initialisatie: halve pagina).
[*]^U | Scroll <*> regels omhoog (`up')
| (default het aantal regels van de vorige
| scroll; initialisatie: halve pagina).
[*]^F | <*> pagina's vooruit (`forward').
[*]^B | <*> pagina's achteruit (`backward') (in oudere
| versies werkt `^B' alleen zonder count).
Als in de volgende commando's het veld <wi> aanwezig is, verandert de `windowsize' in <wi>. Het `window' wordt altijd onderaan geplaatst.
[*]z[wi]<cr>  | Zet regel <*> bovenaan het window
| (default de huidige regel).
[*]z[wi]+ | Zet regel <*> bovenaan het window (default de
| eerste regel van de volgende pagina).
[*]z[wi]- | Zet regel <*> onderaan het window
| (default de huidige regel).
[*]z[wi]^ | Zet regel <*> onderaan het window (default de
| laatste regel van de vorige pagina).
[*]z[wi]. | Zet regel <*> in het midden van het window
| (default de huidige regel).
Terug naar de Index

Mapping en abbreviation

Kijk bij mapping naar de opties `to' en `remap' (zie verderop).
:map <string> <seq>     | <string> wordt ge-interpreteerd als <seq>, bijv.
| `:map ^C :!cc %^V<cr>' om `cc' (de C-kompiler)
| aan te roepen vanuit de editor (vi vervangt `%'
| door de huidige filenaam).
:map | Geef alle mappings.
:unmap <string> | Ontdoe <string> van de mapping. Als vi klaagt
| over `non-mapped macros' (terwijl je geen
| typfout hebt gemaakt), doe dan eerst iets als
| `:map <string> Z' en daarna `:unmap <string>'
| (`Z' moet niet zelf een macro zijn), of ga
| eerst naar `ex'-mode met `Q'.
:map! <string> <seq> | Mapping in append mode, bijv.
| `:map! \be begin^V<cr>end;^V<esc>O<ht>'.
| Als in append mode <string> wordt voorafgegaan
| door `^V', treedt geen mapping op.
:map! | Geef alle append mode mappings.
:unmap! <string> | Ontdoe <string> van de mapping (zie `:unmap').
:ab <string> <seq> | Als <string> in append mode wordt voorafgegaan en
| gevolgd door een breekpunt (bijv. <sp> of `,'),
| wordt hij ge-interpreteerd als <seq>, bijv.
| `:ab ^P procedure'. Een `^V' meteen na
| <string> voorkomt ekspansie.
:ab | Geef alle abbreviations.
:unab <string> | Beschouw <string> niet meer als abbreviation (zie `:unmap').
@<a-z> | Beschouw de inhoud van vermeld register als
| commando, bijv.:
| o0^D:s/fout/goed/<esc>"zdd
| Verklaring:
| o - open een nieuwe regel
| 0^D - haal de indentatie weg
| :s/fout/goed/ - deze inputtekst is een
| `ex'-substitutie-commando
| <esc> - be-eindig de input
| "zdd - haal de zojuist gemaakte
| regel weg en stop hem in
| register `z'
| Nu kun je `@z' typen om `fout' door `goed' te
| vervangen op de huidige regel.
@@ | Herhaal het vorige register-commando.
Terug naar de Index

Switch- en shell-commando's

Q | ^\ | <intr><intr>   | Ga vanuit vi naar `ex' (`quit').
: | Er kan een `ex'-commando gegeven worden.
:vi | Ga vanuit `ex' naar vi.
:sh | Ga naar een subshell, terug naar vi door `^D'.
:[x,y]!<cmd> | Voer een shell-commando uit [op regel x tot en
| met y; deze regels dienen dan als standaard
| input voor het commando en worden vervangen
| door de standaard output].
:[x,y]!! [<args>] | Herhaal het vorige shell-commando (en voeg
| <args> toe).
:[x,y]!<cmd> ! [<args>] | Gebruik het vorige shell-commando (de tweede `!')
| in een nieuw commando.
[*]!<move><cmd> | De shell voert <cmd> uit, met als standaard input
| de regels beschreven door <*><move>.
| De standaard output vervangt vervolgens die
| regels (denk aan `cb', `sort', `nroff', etc.).
[*]!<move>!<args> | Voeg <args> aan het laatste <cmd> toe en voer het
| nieuwe commando uit, met de regels beschreven
| door de huidige <*><move>.
[*]!!<cmd> | Geef <*> regels als standaard input aan het
| shell-commando; de standaard output vervangt
| vervolgens die regels.
[*]!!! [<args>] | Gebruik het vorige commando (met <args>).
:x,y w !<cmd> | Geef regels x tot en met y als standaard input
| aan <cmd> (let op de <sp> tussen de `w' en de
| `!').
:r!<cmd> | Zet de output van <cmd> op een nieuwe regel.
:r <naam> | Lees de file <naam> in (`read').
Terug naar de Index

Het starten van vi

vi [<files>]  | Edit de files, begin bij de eerst pagina van de eerste file.
Verder is het handig de editor te initialiseren m.b.v. de shell-variabele `EXINIT'. Een `EXINIT' ziet er als volgt uit:
        EXINIT='<cmd>|<cmd>|...'
<cmd>: set opties
map ...
ab ...
export EXINIT (in de Bourne-shell)

De lijst van initialisaties kun je echter ook in een file zetten. Als deze file in je home directory staat, de naam `.exrc' heeft EN de variabele EXINIT NIET aangezet is, wordt de lijst automatisch uitgevoerd bij het opstarten. Echter, vi voert een `.exrc' in de huidige directory altijd uit, mits jij de eigenaar van de file bent.
In andere gevallen kun je zelf het uitvoercommando (`source') geven:
:so file
In een `.exrc'-file wordt commentaar ge-introduceerd door een dubbel aanhalings-teken: de rest van de regel wordt genegeerd. Uitzondering: als het laatste commando op de regel een `map[!]'- of `ab'-commando of een shell-escape is, wordt een afsluitend commentaar niet herkend, maar als deel van het commando gezien.

On-line initialisaties zijn mogelijk m.b.v. `vi +<cmd> file', bijv.:

vi +x file              | De cursor springt meteen naar regel x (default
| de laatste regel).
vi +/<string> file | Spring naar het eerste voorkomen van <string>.
Je kunt op een bepaalde `tag' beginnen met:
vi -t <tag>             | Zet de cursor meteen in de goede file op de goede plaats.

Het is soms mogelijk (bijv. na een systeem-crash terwijl je in vi zat) in vi verloren gegane files terug te krijgen door `vi -r file' (`recover'). Als je `vi -r' intypt zonder verdere argumenten, krijg je te zien welke files terug te krijgen zijn.
Als je m.b.v. vi een file slechts wilt bekijken, en enige verandering wilt voorkomen, kun je i.p.v. vi het commando `view' of `vi -R' gebruiken: de optie `readonly' wordt dan automatisch aangezet (met `:w!' kun je alsnog schrijven).

Terug naar de Index


De belangrijkste opties

ai                    | autoindent - In append mode komt de cursor na een <cr> direkt onder de eerste CHAR op de vorige regel.
                      |   Echter, als de optie `lisp' aanstaat, schikt de cursor zich naar het eerste argument van de laatste open lijst.
aw | autowrite - Schrijven bij iedere shell-escape (handig bij kompileren vanuit vi).
dir=<string> | directory - Geeft aan waar vi temporele files kan aanmaken (default `/tmp').
eb | errorbells - Belgerinkel bij fouten (niet op elke terminal).
ic | ignorecase - Bij zoeken wordt geen onderscheid gemaakt tussen hoofd- en kleine letters.
lisp | Herdefinieer de volgende commando's:
| `(', `)' - ga terug (vooruit) over
| S-expressies
| `{', `}' - idem, maar stop niet bij atomen
| `[[', `]]' - ga naar de vorige (volgende) regel
| die begint met een `('
| Zie optie `ai'.
list | <lf> wordt als `$' weergegeven, <ht> als `^I'.
magic | Als deze optie aanstaat, hebben de chars `.', `['
| en `*' bij zoek- en `ex'-substitutie-commando's
| een speciale betekenis; om ze daarvan te
| ontdoen moet je ze vooraf laten gaan door een
| `\'. Als de optie uitstaat, is het precies
| andersom. Meta-karakters:
| ^<string> - <string> moet een regel beginnen
| <string>$ - <string> moet een regel eindigen
| . - matcht elke char
| [a-z] - matcht elke char in de reeks
| [^a-z] - elke char niet in de reeks
| [<string>] - matcht elke char in <string>
| [^<string>] - elke char niet in <string>
| <char>* - 0 of meer <char>s
| \<<string> - <string> moet een woord beginnen
| <string>\> - <string> moet een woord eindigen
modeline | Als je een bestaande file in de buffer leest, en
| deze optie aanstaat, worden de eerste en
| laatste 5 regels bekeken of ze commando's
| bevatten van de volgende vorm:
|
| <sp>vi:set opties|map ...|ab ...|!...:
|
| In plaats van <sp> kan ook <ht> gebruikt
| worden, in plaats van `vi' mag `ex' staan.
| Waarschuwing: deze optie kan vervelende
| gevolgen hebben als je een file edit waar
| `rare' modelines instaan.
nu | number - Nummers voor de regels.
para=<string> | paragraphs - Elk paar chars in <string> wordt
| beschouwd als een paragraph delimiter nroff
| macro (voor `{' en `}'). Een <sp> voorafgegaan
| door `\' geeft aan dat de vorige char een
| eenletterige macro is. Met `:set para=P\ bp'
| geef je vi aan dat `.P' en `.bp' paragrafen
| scheiden. Verder fungeren lege regels en
| sektie-grenzen ook als paragraaf-grenzen.
redraw | Het scherm blijft up to date.
remap | Als deze optie aanstaat (default), worden macro's
| net zolang ge-ekspandeerd totdat ze onveranderd
| blijven. Bijv. als `o' ge-mapped is op `A', en
| `A' is ge-mapped op `I', dan wordt `o'
| ge-mapped op `I' wanneer `remap' aanstaat en
| anders op `A'.
report=<*> | Vi meldt wanneer bijv. een delete- of yank- commando <*> of meer regels beslaat.
ro | readonly - De file mag niet veranderd worden. Echter: met `:w!' kun je toch schrijven.
sect=<string> | sections - Geeft de section delimiters (voor `[['
| en `]]'); zie optie `para'. Een `{' als eerste
| char op een regel geeft ook het begin van een
| sektie aan (denk aan C-funkties).
sh=<string> | shell - Het programma voor shell escapes
| (default `$SHELL' (default `/bin/sh')).
sw=<*> | shiftwidth - Stelt de `schuifbreedte' in (default
| 8 posities).
sm | showmatch - Laat in append mode bij een `)' even
| het bijbehorende `(' zien als dit op dezelfde
| pagina staat; evenzo bij `{' en `}'. Als er
| geen `match' is, geeft vi dat aan met een piep.
taglength=<*> | Het aantal signifikante karakters in `tags'
| (0 = onbeperkt).
tags=<string> | De door spaties gescheiden lijst van `tags'- files.
terse | Voor korte foutmeldingen.
to | timeout - Als deze optie aanstaat, worden append-
| mode mappings alleen ge-interpreteerd als ze
| snel genoeg worden ingetypt.
ts=<*> | tabstop - De lengte van een <ht>; waarschuwing:
| dit geldt alleen IN de editor, daarbuiten
| hebben <ht>'s de normale lengte (default 8
| posities).
wa | writeany - Geen checks bij schrijven (gevaarlijk).
warn | Waarschuwing bij weggaan zonder te schrijven.
wi=<*> | window - Het aantal regels dat vi uit zichzelf laat zien.
wm=<*> | wrapmargin - Vi zet in append mode automatisch een <lf> als er binnen <wm> kolommen van de
| rechtermarge een <sp> of <ht> wordt gezet (0 = zet geen <lf> in de file, wel op het scherm).
ws | wrapscan - Bij zoeken lopen begin en eind van de
| file in elkaar over.
:set <optie> | Zet <optie> aan.
:set no<optie> | Zet <optie> uit.
:set <optie>=<waarde> | Zet <optie> op <waarde>.
:set | Laat alle niet-default opties zien en hun waarde.
:set <optie>? | Geef de waarde van <optie>.
:set all | Laat alle opties zien en hun waarde.
Terug naar de Index


marcolz@stack.nl (Marc Olzheim)

<-Back to Zlo's homepage.