Obsah
1. Vim jako skriptovatelný textový editor
2. Základy skriptovacího jazyka Vimu
3. Použití prefixů před jmény proměnných
8. Slovníky (datový typ DICTIONARY)
1. Vim jako skriptovatelný textový editor
V mnoha snad nikdy nekončících diskusích vedených mezi uživateli textového editoru vi/Vim a uživateli Emacsu je jako jedna z největších předností Emacsu zdůrazňován fakt, že tento textový editor je z velké části napsán v dialektu programovacího jazyka Lisp, který je spouštěn nad relativně malým jádrem přeloženým pro danou platformu, přičemž toto jádro zajišťuje pouze nízkoúrovňové a systémově závislé funkce. Díky tomu je možné chování Emacsu různým způsobem upravovat, programovat makra, vytvářet nové režimy (módy) atd. Je pravda, že původní textový editor vi skutečně v tomto ohledu nemohl Emacsu či ještě staršímu (a nutno říci, že mnohem podivnějšímu :-) editoru TECO konkurovat, protože se v případě vi jedná o typickou ukázku Unixové aplikace – tento nástroj dělá pouze jednu činnost (tou je samozřejmě editace textu), přičemž všechny ostatní činnosti lze provádět díky možnosti volání externích nástrojů, mezi něž patří například grep, sort, fmt, col, indent atd.
Ovšem textový editor Vim nerozšířil pouze repertoár příkazů původního editoru vi, ale taktéž přišel s vlastním interním skriptovacím jazykem, v němž je možné psát jak jednoduché několikařádkové pomocné skripty (ostatně i soubor .vimrc je takovým skriptem), tak i relativně složité nadstavby, například již popsaný Vim Outliner, Java Browser, NERD Tree či Taglist. První verze tohoto skriptovacího jazyka byla představena již v roce 1998 společně s verzí Vim 5, poměrně zásadní rozšíření syntaxe a sémantiky bylo představeno v sedmé verzi Vimu. V případě, že by interní skriptovací jazyk z nějakého důvodu nedostačoval, je dokonce možné psát skripty pro Vim v některém obecném externím jazyku, pro něž je vytvořeno rozhraní, přes které mohou skripty s Vimem komunikovat. Mezi podporované externí jazyky patří například Perl, Python, Tcl, Ruby a dokonce i MzScheme, které by možná mohlo zajímat uživatele Emacsu. V tomto článku se zaměříme především na popis interního skriptovacího jazyka; popis možností propojení Vimu a externích jazyků si necháme až na některý navazující díl tohoto seriálu.
2. Základy skriptovacího jazyka Vimu
Začátky práce s interním skriptovacím jazykem textového editoru Vim nejsou příliš složité, a to zejména z toho důvodu, že syntaxe a sémantika tohoto jazyka se podobná mnoha dalším jazykům, jenž leží na „algolské větvi“ programovacích jazyků, což například znamená, že se běžně pracuje s proměnnými, funkcemi, používají se strukturované příkazy typu programových smyček atd. Dalším důvodem poměrně snadných prvních pokusů o psaní skriptů spočívají v tom, že příkazy skriptovacího jazyka lze zadávat přímo v příkazovém režimu Vimu, tj. ihned po zápisu dvojtečky v normálním režimu. Textový editor Vim se snaží tyto příkazy spustit a vyhodnotit co nejdříve je to možné a popř. vypsat chybové hlášení, pokud se v příkazu vyskytuje chyba. Vim se tedy v tomto ohledu chová podobně jako mnohé interpretry dalších programovacích jazyků (spuštěné v interaktivním režimu), ovšem s tím malým rozdílem, že se implicitně nevypisují vypočtené hodnoty výrazů. To například znamená, že následující výrazy:
:let a=1+1 :let a=a*2 :let b="pokus"
se skutečně „tiše“ provedou, ale pokud budeme chtít znát výsledek výpočtu, musíme explicitně použít příkaz echo:
:echo 1+1 2
:echo a 4
:echo 3*a 12
:echo b pokus
:echo b.b.b pokuspokuspokus
Podobným způsobem je možné zapsat i složitější několikařádkový kód:
:let seznam1=[1,2,3,4] :let i=0 :while i<4 : echo seznam1[i] : let i+=1 :endwhile
(prozatím si nedělejte nic z toho, že kódu nerozumíte, všechny použité příkazy si postupně vysvětlíme)
Pokud si skutečně vyzkoušíte zápis předchozího kódu přímo v příkazovém režimu Vimu, uvidíte, že po zápisu třetího řádku:
:while i<4
se již Vim po stisku klávesy Enter nevrátí zpět do normálního režimu, ale čeká na zadání celého těla smyčky. To je ostatně logické, protože interpret skriptu se snaží smyčku ihned spustit (vyhodnotit). Teprve po zadání posledního řádku:
:endwhile
se smyčka skutečně spustí a vypíšou se jednotlivé prvky uložené v seznamu nazvaném seznam1 (viz též sedmá kapitola pojednávající o seznamech).
Při zápisu výše uvedené programové smyčky přímo v příkazovém režimu jste si pravděpodobně také uvědomili, že pro skripty delší než přibližně pět řádků zdrojového kódu tudy cesta opravdu nevede :-) Textový editor Vim je totiž při tomto způsobu programování v podstatě degradován na poměrně primitivní řádkový editor s historií příkazů. Praktičtější tedy bude využití všech editačních schopností Vimu, včetně zvýrazňování syntaxe zdrojových kódů, doplňování závorek atd. Pokud si tedy předchozí demonstrační příklad:
:let seznam1=[1,2,3,4] :let i=0 :while i<4 : echo seznam1[i] : let i+=1 :endwhile
uložíte do souboru s názvem test.vim, je možné tento soubor přímo ve Vimu otevřít (vim test.vim), provést editaci a následně skript spustit pomocí příkazu:
:source %
nebo pouze:
:so %
Dokonce je v tomto případě možné úplně vynechat všechny dvojtečky na začátcích řádků, takže zdrojový kód bude vypadat lidsky:
let seznam1=[1,2,3,4]
let i=0
while i<4
echo seznam1[i]
let i+=1
endwhile
Poznámka: předchozí příklad není zapsán optimálně; jednodušší je tato smyčka:
let seznam1=[1,2,3,4]
for prvek in seznam1
echo prvek
endfor
3. Použití prefixů před jmény proměnných
Interní skriptovací jazyk Vimu samozřejmě umožňuje práci s proměnnými. Do proměnných lze přiřadit hodnotu pomocí příkazu let, čímž současně dojde i k deklaraci proměnné a přiřazení typu k proměnné (což je důležité, protože typ proměnné není možné libovolně měnit). Pokud totiž proměnná není deklarována, vypsal by Vim při pokusu o přístup k takové neexistující proměnné chybu. Můžeme si to ukázat na jednoduchém příkladu uvedeném pod tímto odstavcem. Všechny příkazy se zapisují v příkazovém režimu, tj. po zadání dvojtečky (texty bez dvojtečky jsou zprávami vypisovanými Vimem):
:let foo=42 :echo foo 42
:echo bar E121: Undefined variable: bar E15: Invalid expression: bar
V závislosti na tom, ve kterém místě je proměnná použita, se Vim automaticky rozhodne, zda se jedná o proměnnou globální nebo lokální v rámci jedné funkce. Ovšem viditelnost proměnných je možné určit i explicitně a to pomocí prefixů, které se zapisují před jméno proměnné. V následující tabulce jsou vypsány všechny prefixy, které je možné ve skriptech i v jednotlivých příkazech použít:
| # | Prefix | Význam prefixu |
|---|---|---|
| 1 | g:jméno_proměnné | globální proměnné |
| 2 | s:jméno_proměnné | proměnné lokální v rámci souboru se skriptem |
| 3 | w:jméno_proměnné | proměnné lokální v rámci okna (nikoli bufferu!) |
| 4 | t:jméno_proměnné | proměnné lokální v rámci tabu |
| 5 | b:jméno_proměnné | proměnné lokální v rámci bufferu (nikoli okna!) |
| 6 | l:jméno_proměnné | proměnné lokální v rámci funkce (jde tedy o „pravé“ lokální proměnné) |
| 7 | a:jméno_proměnné | parametry předávané volané funkci |
| 8 | v:jméno_proměnné | konstanty a proměnné nastavované samotným Vimem |
Zajímavý je především poslední (osmý) prefix, tj. v:. S tímto prefixem lze přistupovat ke konstantám a proměnným, které jsou automaticky nastavované samotným Vimem. Jednou z nejužitečnějších Vimovských proměnných je proměnná v:version obsahující hlavní i vedlejší číslo verze textového editoru, přičemž hlavní číslo je vynásobené hodnotou sto a přičtené k vedlejší verzi, takže například verze 7.2 je uložena ve formě hodnoty 702. Vzhledem k tomu, že výsledkem tohoto interního výpočtu je celé číslo, lze se poměrně často ve skriptech setkat s následujícím obratem:
" verze starsi nez 6.00 neumi pracovat s UTF-8
if v:version>=600
set encoding=utf-8
endif
Použitím samotného prefixu, tj. pouze zápisem g:, v: apod. se přistupuje ke slovníku (dictionary) obsahujícímu všechny proměnné daného typu, například všechny globální proměnné nebo všechny speciální proměnné nastavované textovým editorem Vim. Sami si můžete vyzkoušet, jaké informace se vypíšou po zadání jednoho z následujících příkazů:
echo g: echo t: echo w: echo b:
a především:
echo v:
Poznámka: slovníky l:, s: a a: existují pouze při jejich použití uvnitř funkce.
4. Pseudoproměnné
Kromě globálních proměnných, lokálních proměnných a parametrů funkcí je možné ve Vim skriptu využívat i různé pseudoproměnné. Jedná se o objekty různých typů (konfigurační parametry, registry, proměnné prostředí), jejichž hodnotu lze ve skriptech číst nebo dokonce i měnit a ovlivnit tak chování textového editoru i okolních aplikací (!), popř. zjistit základní informace o konfiguraci systému. Od běžných proměnných se pseudoproměnné odlišují prefixovými znaky, jejichž význam je vypsán v následující tabulce:
| # | Prefix | Význam |
|---|---|---|
| 1 | &jméno_konfiguračního_parametru | lokální nebo globální konfigurační parametr Vimu |
| 2 | &l:jméno_konfiguračního_parametru | lokální parametr Vimu |
| 3 | &g:jméno_konfiguračního_parametru | globální parametr Vimu |
| 4 | @jméno_registru | registr (viz též předchozí části tohoto seriálu s vysvětlením významu některých speciálních registrů) |
| 5 | $jméno_proměnné | proměnná prostředí předávaná do Vimu při jeho spuštění (jedná se o stejné proměnné, s jakými se pracuje v shellu) |
Ukázka výpisu proměnné prostředí
:echo $DISPLAY :0.0 <--- zde se jedná o zprávu vypsanou Vimem
:echo $USER tisnik
Popř. složitější příklad:
:let @"=$PATH p <--- příkaz "put" zadaný v normálním režimu /home/tisnik/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games
5. Použití pseudoproměnných
Ukažme si použití některých pseudoproměnných na jednoduchých příkladech. V jednom článku se objevil návod na definici nových klávesových zkratek, které je možné použít pro zvýšení či snížení hodnoty konfiguračního parametru tabstop (ts). Vzhledem k tomu, že se v těchto mapováních používají výpočty (i když poměrně jednoduché), není možné jednoduše napsat například :set tabstop=xxx, ale je nutné použít krátký skript. V následujícím výpisu si povšimněte použití <CR>, který je součástí mapování. Pokud by nebyl tento znak použit, čekal by Vim na odeslání příkazu klávesou Enter):
nmap ]] :let &tabstop += 1<CR> nmap [[ :let &tabstop -= &tabstop > 1 ? 1 : 0<CR>
Pomocí zápisu @jméno_registru lze číst a dokonce i modifikovat jméno jakéhokoli registru používaného Vimem. Po vykonání následujícího příkazu:
:let @"="foo bar"
… se změní hodnota registru nazvaného " (uvozovky), který je implicitně použit například v příkazu p (put). To znamená, že po stisku klávesy p v normálním režimu se za pozici kurzoru vloží text „foo bar“ (samozřejmě bez uvozovek). Textový editor Vim dokonce při správné konstelaci vhodných podmínek umožňuje číst a modifikovat text uložený v systémové schránce – clipboardu. Již v předchozích částech tohoto seriálu jsme si řekli, že obsah schránky je umístěný v registru nazvaném * nebo + (na systému Windows se jedná o stejnou oblast, na systémech s X11 se rozlišuje schránka a oblast výběru textu – selection). Vyzkoušejte si například spustit tento příkaz:
:let @*="xyzzy"
a následně v emulátoru terminálu či v jiné aplikaci nabízející možnost vstupu textových dat (GEdit, Firefox) stlačit prostřední tlačítko myši. Podobně to funguje i při použití registru +:
:let @+=42
společně s klávesovými zkratkami Ctrl+V, popř. Shift+Insert.
6. Operátory
Ve Vimovských skriptech, přesněji řečeno ve výrazech, je možné použít poměrně široký repertoár různých operátorů. Ve zkratce je možné říci, že snad s výjimkou operátorů ++ a – lze ve Vimu použít prakticky všechny operátory známé z mainstreamových programovacích jazyků:
| Výraz | Popis |
|---|---|
| number + number | součet dvou čísel (též spojení seznamů) |
| number – number | rozdíl dvou čísel |
| number * number | součin dvou čísel |
| number / number | podíl dvou čísel (až u Vimu 7.2 jsou podporována reálná čísla) |
| number % number | dělení modulo |
| +number | konverze na číslo |
| -number | změna znaménka |
| str . str | konkatenace (spojení) řetězců |
| str =~ regexp | porovnání řetězce s regulárním výrazem |
| str !~ regexp | porovnání řetězce s regulárním výrazem (s negací) |
| bool || bool | operace logického součtu |
| bool && bool | operace logického součinu |
| !bool | operace logické negace |
| expr ? expr : expr | ternární operátor známý z céčkových jazyků |
| expr == expr | porovnání čísel či řetězců na rovnost |
| expr != expr | porovnání čísel či řetězců na nerovnost |
| expr > expr | porovnání čísel či řetězců na relaci „větší než“ |
| expr >= expr | porovnání čísel či řetězců na relaci „větší nebo rovno“ |
| expr < expr | porovnání čísel či řetězců na relaci „menší než“ |
| expr <= expr | porovnání čísel či řetězců na relaci „menší nebo rovno“ |
| var = expr | běžné přiřazení |
| var += expr | přičtení hodnoty výrazu k proměnné |
| var -= expr | odečtení hodnoty výrazu od proměnné |
| var *= expr | vynásobení proměnné hodnotou výrazu |
| var /= expr | vynásobení proměnné hodnotou výrazu |
| var %= expr | zkrácený zápis var = var % expr |
| var .= expr | konkatenace řetězců |
Již ve čtvrté části tohoto seriálu jsme si řekli, že u všech operátorů porovnávajících řetězce (jedná se o operátory ==, =~, !~) je možné s využitím postfixového znaku určit, zda se má ignorovat velikost písmen, popř. zda se má použít konfigurační parametr ignorecase:
| Operátor | Použít ignorecase | Brát ohled na velikost písma | Ignorovat velikost písma |
|---|---|---|---|
| equal | == | ==# | ==? |
| not equal | != | !=# | !=? |
| greater than | > | ># | >? |
| greater than or equal | >= | >=# | >=? |
| smaller than | < | <# | <? |
| smaller than or equal | <= | <=# | <=? |
| regexp matches | =~ | =~# | =~? |
| regexp doesn't match | !~ | !~# | !~? |
7. Seznamy (datový typ LIST)
V předchozích kapitolách jsme se zabývali především tím, jakým způsobem se pracuje s celými čísly (popř. s reálnými čísly ve Vimu 7.2) a s řetězci. Po relativně dlouhou dobu přibližně deseti let skutečně bylo možné ve Vimovských skriptech používat tuto dvojici primitivních datových typů, ovšem spolu se sedmou verzí se objevily i dva nové datové typy známé i z mnoha dalších (nejenom) skriptovacích programovacích jazyků, například z Perlu, Pythonu či Ruby. Těmito novými typy jsou seznamy (list) a slovníky (dictionary). Nejprve si popíšeme způsob práce se seznamy. V pojetí Vim Scriptu se seznam chová podobně jako v programovacích jazycích Lisp či Scheme, což znamená, že do seznamu lze vkládat buď přímo základní datové typy čísla a řetězce) nebo další seznamy a vytvářet tak poměrně komplikované hierarchizované datové struktury (v Lispu lze do seznamu zapsat i celý program či funkci, to prozatím ve Vimu není možné a kvůli orientaci Vim Scriptu na syntaxi odvozenou od mainstreamových jazyků ani možné nebude). Jednoduchý seznam lze vytvořit například následujícím příkazem (konstruktorem):
:let seznam1=[1, 2, 3, 4] :echo seznam1 [1, 2, 3, 4]
Jak jsme si již řekli v prvním odstavci, je v seznamu možné kombinovat jednotlivé datové typy Vimu. Taktéž si povšimněte, že jméno proměnné se správně vyhodnotí na její hodnotu:
:let two=2 :let seznam2=[1, two, "3", "čtyři"] :echo seznam2 [1, 2, "3", "čtyři"]
Seznam složený z jiných seznamů se vytvoří následujícím konstruktorem (jedná se tedy o seznam seznamů, který můžeme v tomto specifickém případě považovat za dvourozměrné pole):
:let seznam3=[[11, 12, 13] , [21, 22, 23], [31, 32, 33]] :echo seznam3 [[11, 12, 13] , [21, 22, 23], [31, 32, 33]]
K prvkům seznamu se přistupuje pomocí takzvaného selektoru, který se zapisuje jako index v hranatých závorkách, podobně jako pole v céčku, Pascalu a dalších programovacích jazycích. První prvek seznamu má nulový index, další prvek má index rovný jedničce atd. Pokud je seznam složený z více seznamů (tj. nějaký prvek seznamu je opět tvořen seznamem), používá se indexace pomocí dvou indexů, z nichž každý musí být umístěn v samostatných hranatých závorkách. „Nejlevější“ index přitom ovlivňuje výběr prvku z nejvýše postaveného seznamu v hierarchii. Práce s prvky seznamu tedy může vypadat následovně:
:let prvni=seznam1[0] :echo prvni
:let seznam2[1]="pokus" :echo seznam2
:let seznam3=[[11, 12, 13] , [21, 22, 23], [31, 32, 33]] :echo seznam3[2][2]
Pokud nastane při indexaci chyba, tj. indexuje se neexistující prvek (například při průchodu seznamem pomocí programové smyčky), vypíše Vim chybové hlášení list index out of range a ukončí provádění dalších příkazů. Při psaní skriptů je však výhodnější, aby si skript sám otestoval, zda k seznamu opravdu přistupuje korektním způsobem. K „bezpečnému“ přístupu k prvkům seznamu je možné použít funkci get(), která v případě, že se přistoupí k indexu mimo povolený rozsah vrátí nulovou hodnotu. Prvním parametrem funkce get() je proměnná typu seznam, druhým parametrem je index:
:echo "Indexy v zadaném rozsahu" :echo get(seznam1, 1) :echo get(seznam1, 2)
:echo "Indexy mimo rozsah" :echo get(seznam1,-1) :echo get(seznam1, 4)
Pro spojení dvou seznamů je rozšířena funkce operátoru +. Seznamy jsou spojeny tak, že se zřetězí všechny jejich prvky na nejvyšší úrovni. V případě, že je některým prvkem seznamu další seznam, není spojením ovlivněn. Vyzkoušet si operaci spojení seznamů můžeme na následujících příkladech:
:echo [1,2]+[3,4] :let seznam1=[1, 2, 3] :let seznam2=["3", "4", "5"] :let seznam3=[[11, 12, 13] , [21, 22, 23], [31, 32, 33]] :let spojeni=seznam1+seznam2+seznam3 :echo spojeni
8. Slovníky (datový typ DICTIONARY)
Pod datovým typem slovník (dictionary) se v textovém editoru Vim neskrývá nic jiného, než asociativní pole, které je známé i z velkého množství dalších programovacích jazyků, jakými jsou Perl, Python, Lua či JavaScript. Malým omezením Vimovsky pojatého asociativního pole je skutečnost, že klíčem musí být vždy řetězec, což poněkud komplikuje přístup k jednotlivým prvkům pole (klíče jiných typů jsou ovšem na řetězec převedeny). Slovník se jednoduše vytvoří pomocí konstruktoru, který musí splňovat následující schéma, ve kterém se postupně naplňují jednotlivé hodnoty společně se svými klíči. Jak jsme si již řekli, musí být klíč vždycky reprezentován řetězcem. Pokud tomu tak při zápisu konstruktoru není, je klíč na řetězec nejprve převeden:
{"klíč1":hodnota1, "klíč2":hodnota2}
Příklad použití:
:let slovnik1={"one":1, "two":2, "three":3, "four":4}
:echo slovnik1
{'one': 1, 'two': 2, 'three': 3, 'four': 4 }
Přístup k jednotlivým prvkům uloženým ve slovníku je podobný způsobu, který byl využitý v případě seznamů, pouze se namísto číselného indexu použije klíč ve formě řetězce (to je pravděpodobně jeden z důvodů, proč musí být klíče slovníku vždy řetězce). Kromě toho je podporována i takzvaná tečková notace, kdy se před tečku zapíše jméno slovníku a za tečku klíč bez uvozovek. Slovník se potom v podstatě chová jako strukturovaný datový typ záznam (record, struct) s měnitelným počtem položek. Opět se nejedná o neznámé chování, protože podobně se s asociativními poli pracuje například v JavaScriptu nebo v programovacím jazyku Lua. Následuje ukázka použití obou možností přístupu k prvkům uloženým ve slovníku:
:let seznam2={"one":1, "two":2, "three":3}
:echo seznam2["one"]
1
:echo seznam2.one 1
Řetězec představující klíč sice může obsahovat i české znaky (popř. i další znaky s nabodeníčky či další Unikódové specialitky), potom však nelze selektor použít ve formě tečkové notace, protože by se tím porušila syntaktická pravidla skriptovacího jazyka:
:let seznam3={"jedna":1, "dvě":2, "tři":3}
:echo seznam3["tři"]
3
:echo seznam3.tři E716: Key not present in Dictionary: tři
Ve třetí kapitole jsme se zmínili o tom, že prefixy typů proměnných ve skutečnosti nahrazují slovníky. Můžeme si to ihned vyzkoušet:
:let xx=v: :echo xx["version"] 701 :echo xx.version 701
:echo xx["progname"] gvim :echo xx.progname gvim
Další možnosti práce se slovníky budou popsány v navazující části seriálu.
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
ČLÁNKY DO MAILU