Obsah
1. Základní řídicí příkazy – podmínky
2. Programová smyčka typu while
3. Programová smyčka typu foreach při práci se seznamy (list)
4. Seznamy seznamů – jeden ze způsobů reprezentace matic
5. Programová smyčka typu foreach při práci se slovníky (dictionary)
6. Jak lze ve Vim Scriptu elegantně vytvořit počítané programové smyčky?
8. Ukázka využití bloku try-catch-endcatch
1. Základní řídicí příkazy – podmínky
V šesté části seriálu o využití textového editoru Vim ve funkci vývojového prostředí jsme si řekli základní informace o Vim Scriptu, tj. o interním skriptovacím jazyce, v němž je možné psát jak jednoduché pomocné funkce, tak i poměrně složité moduly typu JavaBrowser či NERD tree. Víme již, že ve skriptech je možné používat číselné hodnoty či řetězce a taktéž je možné využívat seznamy (list) a slovníky (dictionary). Taktéž jsme si řekli, že před jména proměnných lze zapisovat prefixy, pomocí nichž se rozlišují lokální proměnné, globální proměnné, proměnné vztažené k editovanému bufferu atd. Pomocí dalších prefixů lze přistupovat k takzvaným pseudoproměnným, například ke konfiguračním parametrům či proměnným prostředí (shellu). Ovšem prozatím jsme se neseznámili s tím, jakým způsobem je možné řídit běh programu, tj. jak lze tvořit větvení a programové smyčky.
Pro větvení se využívá, tak jako v naprosté většině dalších imperativních programovacích jazyků, příkaz if s ukončujícím příkazem endif. Kromě toho lze použít i nepovinnou větev else, popř. větev else s podmínkou, pro niž se používá klíčové slovo elseif. Syntaxe zápisu všech možností vypadá následovně:
if podmínka
blok spuštěný při splnění podmínky
endif
if podmínka
blok spuštěný při splnění podmínky
else
blok spuštěný při nesplnění podmínky
endif
if podmínka
blok spuštěný při splnění první podmínky
elseif podmínka
blok spuštěný při splnění druhé podmínky
elseif podmínka
blok spuštěný při splnění třetí podmínky
else
blok spuštěný při nesplnění žádné podmínky
endif
Obrázek 1: Příklad použití příkazů if v souboru .vimrc, který je automaticky načítán při spouštění Vimu. V zobrazeném zdrojovém kódu je na základě obsahu globální proměnné resolution provedeno nastavení počtu zobrazených sloupců a řádků.
Ukažme si nyní základní využití příkazu if. Většina skriptů nebo doplňkových modulů (plugins) nemusí pracovat korektně v tom případě, když je nastaven režim kompatibility s původním textovým editorem vi. Do tohoto režimu se Vim může dostat například tehdy, pokud je spuštěn příkazem vi (zde ovšem záleží na konkrétní konfiguraci systému) nebo tehdy, když je použita volba:
:set compatible
Obrázek 2: Na začátku tohoto skriptu je proveden test, zda se textový editor Vim nenachází v režimu kompatibility s původním textovým editorem „vi“. V režimu kompatibility není možné provádět velké množství užitečných operací.
V režimu kompatibility přestane pracovat velká část zajímavých a užitečných funkcí Vimu (ostatně si to sami můžete vyzkoušet), proto mnohé skripty a zásuvné moduly na začátku svého běhu testují, zda je režim kompatibility nastaven a pokud tomu tak skutečně je, tak napíšou chybovou zprávu a skončí běh skriptu pomocí řídicího příkazu finish. U mnoha skriptů tedy můžeme na jejich začátku nalézt následující kód:
if &compatible
echo "Tento skript nebude pracovat v rezimu kompatibility"
finish
endif
Připomeňme si, že prefixem & začíná jméno pseudoproměnné obsahující hodnotu stejně pojmenovaného konfiguračního parametru. Výše uvedený příklad skutečně pracuje, ovšem korektnější je, aby skript vypisovat chybová hlášení pouze v případě, kdy je nastaven konfigurační parametr verbose. U „slušných“ skriptů respektujících uživatelské nastavení textového editoru Vim tedy můžeme nalézt dvojici do sebe vnořených podmínek:
if &compatible
if &verbose
echo "Tento skript nebude pracovat v rezimu kompatibility"
endif
finish
endif
2. Programová smyčka typu while
Kromě větvení běhu programu na základě nějaké podmínky je mnohdy nutné provádět určitou část kódu opakovaně. Může se například jednat o kód, který prochází všemi editovanými buffery, popř. prochází položkami seznamu či dvojicemi klíč-hodnota uloženými ve slovníku. Pro tyto účely jsou ve Vimu k dispozici dva typy smyček. První smyčkou – tou zcela základní, na níž lze postavit jakýkoli algoritmus – je smyčka typu while, která začíná příkazem while společně s podmínkou a blokem programového kódu a končí příkazem endwhile. Podmínkou může být jakýkoli výraz, který se vyhodnotí na pravdu či nepravdu. Pokud se výraz vyhodnotí na pravdu (nenulová hodnota), je provedeno tělo smyčky, tj. jedna iterace a řízení se posléze vrátí zpět na vyhodnocení podmínky. Pokud se naopak výraz vyhodnotí na nepravdu, je řízení ihned přesunuto za tělo smyčky, což mj. znamená, že se programová smyčka typu while ve skutečnosti nemusí provést ani jednou:
while podmínka
blok kódu
endwhile
Obrázek 3: Použití programových smyček typu while v modulu justify.vim, který je dodáván společně se samotným Vimem.
Ukažme si velmi jednoduchý ilustrační příklad, v němž je programová smyčka typu while použita ve funkci počítané smyčky, kterou Vim Script ve skutečnosti neobsahuje (i když ji lze částečně nahradit, jak si řekneme v páté kapitole):
let i = 1
while i <= 10
echo "aktualni hodnota pocitadla: " . i
let i = i + 1
endwhile
Pokud si tento příklad uložíte do samostatného souboru while.vim, postačuje tento soubor otevřít ve Vimu a v příkazovém režimu napsat následující příkaz:
:source %
popř.:
:so %
Obrázek 4: Ukázka běhu demonstračního příkladu využívajícího programovou smyčku typu while.
Ve druhém demonstračním příkladu je ukázána jednoduchá manipulace s řetězcem – postupné odstraňování prvního znaku z řetězce s využitím operace substring, kterou lze zapsat pomocí konstrukce [ start : end ]:
let str = "http://www.root.cz"
while str != ""
echo str
let str = str[1 : strlen(str) - 1]
endwhile
Podobně jako v dalších programovacích jazycích, i ve Vimu je možné ovlivnit smyčku while dvojicí příkazů break a continue. První z těchto příkazů ihned ukončí běh smyčky, přičemž běh programu bude pokračovat na prvním příkazu uvedeným za smyčkou. Naproti tomu příkaz continue vrátí běh programu na podmínku testovanou před prvním provedením těla smyčky. Příkaz break je použit v následujícím příkladu pro ukončení programové smyčky v případě, že testovaný řetězec začíná znaky „root“. Již v předchozí části tohoto seriálu jsme si řekli, že pomocí operátoru =~ je možné zapsat test na to, zda obsah nějakého řetězce (popř. proměnné obsahující řetězec) odpovídá zadanému regulárnímu výrazu:
let str = "http://www.root.cz"
while str != ""
echo str
if str =~ "^root.*"
break
endif
let str = str[1 : strlen(str) - 1]
endwhile
3. Programová smyčka typu foreach při práci se seznamy (list)
Již v předchozí části tohoto seriálu jsme si řekli, že ve Vim Scriptu je od verze Vim 7.0 podporován i datový typ seznam (list). Připomeňme si, že seznam lze vytvořit pomocí takzvaného konstruktoru, který může mít následující podobu:
:let seznam1=[1, 2, 3, 4]
Se seznamem je možné pracovat jako s celkem:
:echo seznam1 [1, 2, 3, 4]
popř. lze přistupovat k jednotlivým prvkům seznamu:
:let prvni=seznam1[0] :echo prvni
:let seznam1[1]="pokus" :echo seznam1
Obrázek 5: Zdrojový kód demonstračního příkladu uvedeného v předchozí kapitole.
Velmi často je nutné postupně procházet všemi prvky seznamu a provádět s nimi nějakou operaci, například hodnoty prvků postupně předávat do nějaké funkce. Pro tuto činnost lze samozřejmě použít v předchozí kapitole popsanou programovou smyčku typu while, pomocí níž se bude postupně zvyšovat hodnota pomocné numerické proměnné (počitadla) takovým způsobem, aby se postupně prošlo indexy všech prvků v seznamu. Základní podoba této smyčky může vypadat následovně:
let seznam1=[1,2,3,4,5]
let i=0
while i < 5
echo seznam1[i]
let i = i + 1
endwhile
Ovšem jednodušší je použít namísto magické konstanty 5 funkci len(), popř. lze navíc pro přístup k prvkům seznamu používat funkci get:
let seznam1=[1,2,3,4,5]
let i=0
while i < len(seznam1)
echo get(seznam1, i)
let i = i + 1
endwhile
Ani to však není nejlepší řešení, protože se musí relativně složitě pracovat s čítačem smyčky, explicitně přistupovat ke každému prvku seznamu apod. Textový editor Vim zde nabízí mnohem lepší řešení, které je používáno i v mnoha dalších vyšších programovacích jazycích. Jedná se o smyčku typu foreach, která automaticky projde všemi prvky seznamu, a to ve správném pořadí. I když se pro zápis této smyčky používá klíčové slovo for, je význam smyčky odlišný od podobně nazvaných C-čkovských smyček. Výše uvedená smyčka while – endwhile se tedy může přepsat následovně:
let seznam1=[1,2,3,4,5]
for item in seznam1
echo item
endfor
Obrázek 6: Příklad použití smyčky typu foreach v reálném skriptu.
4. Seznamy seznamů – jeden ze způsobů reprezentace matic
Můžeme si také vyzkoušet složitější příklad, v němž se seznam používá pro reprezentaci matice (přesněji řečeno seznamu seznamů). Tento příklad po svém spuštění uloží do registru nazvaného " text obsahující matici, jejíž prvky mají dvojnásobnou hodnotu, než odpovídající prvky z původní matice:
let matrix = [ [1,2,3], [4,5,6], [7,8,9] ]
let yank_reg = ""
for row in matrix
for item in row
let yank_reg = yank_reg . "\t" . (item*2)
endfor
let yank_reg = yank_reg . "\n"
endfor
let @" = yank_reg
Obrázek 7: Demonstrační příklad pracující se seznamem seznamů.
Obsah registru " je možné uložit za pozici kurzoru pomocí příkazu p (put), protože tento registr je u editačních operací používán implicitně. Stejný příkaz je však možné zavolat přímo ze skriptu s využitím klíčového slova normal:
let matrix = [ [1,2,3], [4,5,6], [7,8,9] ]
let yank_reg = ""
for row in matrix
for item in row
let yank_reg = yank_reg . "\t" . (item*2)
endfor
let yank_reg = yank_reg . "\n"
endfor
let @" = yank_reg
normal p
(dejte si pozor, na kterém místě se textový kurzor při spouštění skriptu nachází).
Obrázek 8: Demonstrační příklad pracující se seznamem seznamů po svém spuštění. V dolní části editační plochy je vypsán výsledek práce tohoto příkladu.
5. Programová smyčka typu foreach při práci se slovníky (dictionary)
Programovou smyčku typu foreach popsanou v předchozí kapitole je možné kromě průchodu seznamem použít i pro procházení slovníků (dictionary). Již v předchozí části tohoto seriálu jsme si řekli, že klíči ve slovnících mohou být pouze řetězce, což však poněkud zmenšuje možnosti průchodu celým slovníkem s využitím programové smyčky typu while. Textový editor Vim však obsahuje interní funkci keys(), která vrací všechny klíče ve slovníku ve formě seznamu řetězců. S využitím této funkce je možné smyčku pro průchod slovníkem napsat – i když dosti nešikovně – například následujícím způsobem:
let dictionary={"one":1, "two":2, "three":3, "four":4}
echo dictionary
let keys=keys(dictionary)
let i = 0
while i < len(keys)
let key = get(keys, i)
echo "Klic: " . key . "\thodnota: " . dictionary[key]
let i = i + 1
endwhile
Popř. mnohem jednodušeji a čitelněji s využitím konstrukce foreach:
let dictionary={"one":1, "two":2, "three":3, "four":4}
echo dictionary
for key in keys(dictionary)
echo "Klic: " . key . "\thodnota: " . dictionary[key]
endfor
Obrázek 9: Procházení slovníkem pomocí programové smyčky typu while.
Jak je z předchozího příkladu patrné, nejprve se převedou všechny klíče na seznam a poté se využije výše popsaná smyčka for – endfor, která slouží k průchodu seznamem. Je zde však jeden poměrně zásadní rozdíl: zatímco u seznamů bylo zaručeno, že se prvky seznamu prochází postupně od prvku prvního směrem k prvku poslednímu, u slovníků (neboli asociativních polí, hashů) je pořadí zdánlivě náhodné a odpovídá způsobu interní reprezentace slovníku v operační paměti, což je ostatně patrné i ze zpráv vypsaných předchozím demonstračním příkladem:
{'four': 4, 'one': 1, 'two': 2, 'three': 3}
Klic: four hodnota: 4
Klic: one hodnota: 1
Klic: two hodnota: 2
Klic: three hodnota: 3
Klíče je však možné například seřadit s využitím interní funkce sort(), čímž se stane průchod slovníkem více deterministický; viz též následující příklad:
let dictionary={"aaa":1, "xxx":2, "ccc":3, "zzz":4}
echo dictionary
let sorted_keys = sort(keys(dictionary))
for key in sorted_keys
echo "Klic: " . key . "\thodnota: " . dictionary[key]
endfor
Výsledek běhu předchozího demonstračního příklad je následující:
{'zzz': 4, 'xxx': 2, 'ccc': 3, 'aaa': 1}
Klic: aaa hodnota: 1
Klic: ccc hodnota: 3
Klic: xxx hodnota: 2
Klic: zzz hodnota: 4
Obrázek 10: Procházení slovníkem pomocí programové smyčky typu foreach.
Seznam klíčů je samozřejmě možné setřídit opačně, k čemuž lze využít buď vlastní porovnávací funkci, nebo na již setříděný seznam zavolat funkci reverse(). Vzhledem k syntaktickým omezením Vim Scriptu je však v tomto případě nutné tuto funkci volat pomocí konstrukce call (Vim Script by totiž nepoznal, že se jedná a volání funkce a předpokládal by, že reverse je nějaký příkaz):
let dictionary={"aaa":1, "xxx":2, "ccc":3, "zzz":4}
echo dictionary
let sorted_keys = sort(keys(dictionary))
call reverse(sorted_keys)
for key in sorted_keys
echo "Klic: " . key . "\thodnota: " . dictionary[key]
endfor
Výsledek běhu předchozího demonstračního příklad je zobrazen níže:
{'zzz': 4, 'xxx': 2, 'ccc': 3, 'aaa': 1}
Klic: zzz hodnota: 4
Klic: xxx hodnota: 2
Klic: ccc hodnota: 3
Klic: aaa hodnota: 1
6. Jak lze ve Vim Scriptu elegantně vytvořit počítané programové smyčky?
Po přečtení předchozích kapitol se možná ptáte, jakým způsobem se tedy ve Vim Scriptu mohou zapisovat počítané smyčky typu for známé z programovacích jazyků náležejících do Algolské větve. Samozřejmě je možné pro implementaci počítané smyčky použít konstrukci while a endwhile. To je však poměrně nečitelné, jak jsme mohli vidět na příkladu uvedeném ve druhé kapitole:
let i = 1
while i <= 10
echo "aktualni hodnota pocitadla: " . i
let i = i + 1
endwhile
Vim Script sice neobsahuje „pravou“ počítanou smyčku typu for, ovšem lze ji implementovat s využitím smyčky foreach a interní funkce range(). Tato užitečná funkce na základě svých parametrů vytvoří posloupnost čísel uloženou v seznamu a průchod seznamem (zde konkrétně seznamem čísel) již známe. Nejprve si ukažme, jak funkce range() pracuje. Pokud je funkce zavolána pouze s jedním parametrem n (jímž by mělo být kladné číslo), vrátí aritmetickou řadu začínající nulou a končící hodnotou n-1:
:echo range(10) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Samozřejmě je také možné zadat hodnotu prvního a posledního čísla v aritmetické posloupnosti. V tomto případě má funkce range() dva parametry: hodnotu prvního prvku a hodnotu prvku posledního. Stále se však jedná o rostoucí posloupnost, tj. druhý parametr by měl být vyšší, než parametr první, jinak se vrátí buď jednoprvkový seznam (shodná hodnota obou parametrů) nebo prázdný seznam (popř. se nahlásí chyba):
:echo range(1, 10) [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
:echo range(6, 16) [6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
Jednoprvkový seznam:
:echo range(10, 10) [10]
V mnoha skriptech je taktéž nutné zadat krok v aritmetické posloupnosti – právě tímto způsobem je možné vytvořit klesající posloupnost (krok se zadává jako třetí nepovinný parametr):
Kladný krok:
:echo range(0, 10, 2) [0, 2, 4, 6, 8, 10]
Záporný krok:
:echo range(10, 1, -1) [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
Obrázek 11: Zdrojový kód demonstračního příkladu pro výpis sudých řádků z aktuálně editovaného bufferu.
Nyní se již konečně dostáváme k využití této funkce při tvorbě počítaných smyček. Asi nebude velkým překvapením, že smyčku lze s využitím funkce range() zapsat velmi jednoduše
for i in range(1, 10)
echo "aktualni hodnota pocitadla: " . i
endfor
Podobnou konstrukci je možné použít například při průchodu všemi řádky aktuálně editovaného bufferu. Povšimněte si použití interní funkce line(), která vrací číslo textového řádku v závislosti na řetězci zadaném jako parametr této funkce. Více informací si o této funkci řekneme v následujících částech tohoto seriálu:
let max = line("$")
for n in range(1, max)
echo getline(n)
endfor
Samozřejmě je možné procházet například všemi sudými řádky od aktuální pozice kurzoru směrem ke konci souboru, atd. atd.:
let max = line("$")
let current = line(".")
for n in range(current, max, 2)
echo getline(n)
endfor
Obrázek 12: Část zdrojového kódu tohoto článku, z něhož se zobrazují jen sudé řádky.
7. Zpracování výjimek
Skriptovací jazyk Vim Script obsahuje – možná poněkud překvapivě – i konstrukci používanou při zachycování a zpracování výjimek, tj. různých chybových stavů, které mohou během práce skriptu nastat. Samotný princip zachycení výjimek není nijak neobvyklý, ale vzhledem k tomu, že Vim Script sice umožňuje práci s objekty, ale není plně objektově orientovaný, je každá výjimka jednoduše reprezentovaná řetězcem, jehož obsah odpovídá řetězci, který je v případě chyby vypsán uživateli do okna Vimu (zprávy o chybách mohou být samozřejmě ovlivněny aktuálně nastaveným jazykovým prostředím). Právě na základě chybového řetězce nebo jeho části může být výjimka skriptem zachycena a nějakým způsobem zpracována. Přitom se velmi často využívá faktu, že každé chybové hlášení ve Vimu začíná číslem chyby. Toto chování textového editoru si můžete jednoduše vyzkoušet, například zadáním následujících příkazů.
Pokus o zápis obsahu bufferu do souboru či zařízení, pro nějž není zápis povolený:
:set readonly :w
Obrázek 13: Chybové hlášení vypsané při pokusu o zápis do souboru otevřeného v režimu read only.
Zadání špatného regulárního výrazu pro vyhledávání (závorka není párová):
/\)
Pro odchycení výjimky se používá blok try-catch-endtry, popř. try-catch-finally-endtry, který má následující strukturu:
try
blok příkazů
catch regulární výraz
blok s příkazy reagujícími na výjimku
endtry
Popř. lze použít blok rozšířený o větev finally:
try
blok příkazů
catch regulární výraz
blok s příkazy reagujícími na výjimku
finally
blok provedený nezávisle na tom, zda výjimka vznikne
endtry
Taktéž je možné blok catch zcela vynechat:
try
blok příkazů
finally
blok provedený nezávisle na tom, zda výjimka vznikne
endtry
Obrázek 14: Chybová zpráva vypsaná ve chvíli, kdy není hledaný vzor v textu nalezen.
8. Ukázka využití bloku try-catch-endcatch
Po rychlém teoretickém úvodu do problematiky výjimek ve Vim Scriptu si již můžeme ukázat jednoduchý příklad (převzatý přímo z nápovědy k Vimu). V tomto příkladu probíhá pokus o otevření souboru na zadané cestě a pokud soubor neexistuje, je o tom uživatel informován hlášením vypsaným pomocí nám již známého příkazu echo:
try
read ~/templates/pascal.tmpl
catch /E484:/
echo "Sorry, the Pascal template file cannot be found."
endtry
Jak je z tohoto zdrojového příkladu patrné, je zachycována chyba s číslem 484. Číslo této chyby bude vždy stejné, nezávisle na tom, v jakém jazykovém prostředí je Vim ve skutečnosti spuštěn. Ovšem regulární výraz pro zachycení výjimky může být i složitější, což můžeme vidět z příkladu uvedeném níže:
try
let config_lines = readfile('/etc/udev/udev.conf')
catch /^Vim\%((\a\+)\)\=:E484/
return
endtry
Obrázek 15: Chybová zpráva vypsaná ve chvíli, kdy je vyhledávaný vzor chybný kvůli chybějící párové závorce.
Samozřejmě je taktéž možné zachytit a nějakým způsobem reagovat na větší množství výjimek:
try
call execute_code
catch /E484:/
echo "No type annotations (.annot) file found"
catch /no_expression/
echo "No expression found under the cursor"
catch /no_annotation/
echo "No type annotation found for the given text"
catch /malformed_annot_file/
echo "Malformed .annot file"
endtry
Obrázek 16: Dvojice výjimek, v jejichž chybovém řetězci jsou sice použita lokalizovaná hlášení, ovšem číslo chyby zůstává stále stejné.
9. Odkazy na Internetu
- Clewn home page
http://clewn.sourceforge.net/ - How to connect vim with gdb – using clewn
http://chunhao.net/blog/how-to-connect-vim-with-gdb-using-clewn - yavdb : Yet Another (Generic) Vim Debugger Integration
http://www.vim.org/scripts/script.php?script_id=1954 - Vim home page
http://www.vim.org/ - Exuberant ctags
http://ctags.sourceforge.net/ - xxd (man page)
http://www.linux-tutorial.info/modules.php?name=ManPage&sec=1&manpage=xxd - vim (man page)
http://www.linux-tutorial.info/modules.php?name=ManPage&sec=1&manpage=vim - ctags (man page)
http://www.linux-tutorial.info/modules.php?name=ManPage&sec=1&manpage=ctags - cscope (man page)
http://www.linux-tutorial.info/modules.php?name=ManPage&sec=1&manpage=cscope - Tutorial: Make Vim as Your C/C++ IDE Using c.vim Plugin
http://www.thegeekstuff.com/2009/01/tutorial-make-vim-as-your-cc-ide-using-cvim-plugin/ - c.vim : C/C++ IDE
http://vim.sourceforge.net/scripts/script.php?script_id=213 - c.vim : C/C++ IDE key mappings
http://lug.fh-swf.de/vim/vim-c/c-hotkeys.pdf - Základní základy editoru Vim
http://www.root.cz/clanky/zakladni-zaklady-editoru-vim/ - Jak si přizpůsobit Vim
http://www.root.cz/serialy/jak-si-prizpusobit-vim/ - Novinky ve VIM 7: Úvodní část – speller
http://www.root.cz/vim-sedm-prvni-cast/ - Novinky ve VIM 7: Skriptovací jazyk
http://www.root.cz/vim-sedm-druha-cast/ - vim2elvis: Přednosti a nedostaky Elvise v porovnání s Vimem
http://www.root.cz/clanky/vim2elvis-1/ - vim2elvis: Shodné znaky mezi Elvisem a Vimem, nastaveníeditoru
http://www.root.cz/clanky/vim2elvis-2/ - Nej… VIM pluginy (1)
http://www.root.cz/clanky/nej-vim-pluginy/ - Taglist (plugin)
http://www.vim.org/scripts/script.php?script_id=273 - The NERD tree: A tree explorer plugin for navigating the filesystem
http://www.vim.org/scripts/script.php?script_id=1658 - JavaBrowser : Shows java file class, package in a tree as in IDEs. Java source browser.
http://www.vim.org/scripts/script.php?script_id=588 - snippetsEmu : An attempt to emulate TextMate's snippet expansion
http://www.vim.org/scripts/script.php?script_id=1318 - Scroll Lock (Necyklopedie)
http://necyklopedie.wikia.com/wiki/Scroll_lock - Caps Lock (Necyklopedie)
http://necyklopedie.wikia.com/wiki/Caps_Lock - Avoid the escape key
http://vim.wikia.com/wiki/Avoid_the_escape_key - Map caps lock to escape in XWindows
http://vim.wikia.com/wiki/VimTip166
