Obsah
1. Užitečné skripty a pluginy pro textový editor Vim: propojení Vimu s debuggery
2. Princip propojení Vimu s debuggery
3. Funkce Vimu, které jsou používané pluginy spolupracujícími s debuggery
10. Odkazy na předchozí části článku
1. Užitečné skripty a pluginy pro textový editor Vim: propojení Vimu s debuggery
Textový editor Vim se díky svému skriptovacímu jazyku Vim Script, podpoře maker, záložek (tabů), oken a bufferů může po instalaci vhodných pluginů změnit v poměrně robustní a přitom výkonné integrované vývojové prostředí, které navíc odpovídá unixové filozofii – Vim je v tomto případě komponentou volající další aplikace a nástroje, nikoli monolitickým programem, který teoreticky umí všechno, ovšem nic pořádně. :-) V mnoha případech musí programátoři použít debugger pro nalezení chyby v programu a právě v této chvíli stojí před rozhodnutím, zda debugger spustit v samostatném terminálu nebo zda naopak použít vhodný plugin pro spuštění a především pro ovládání debuggeru přímo z Vimu. Druhá možnost je v mnoha ohledech lepší, protože debugger ovládaný z příkazové řádky (gdb apod.) sice uživatelům nabízí nepřeberné množství mnohdy i velmi komplikovaných příkazů, na druhou stranu však nemá všechny možnosti celoobrazovkového debuggeru, na který jsou dnešní programátoři zvyklí.
Obrázek 1: Typické „sezení“ programátora využívajícího debugger gdb. Přeložení programu s vygenerováním ladicích informací (-g) a následné spuštění debuggeru.
Pro Vim vzniklo relativně velké množství pluginů zajišťujících propojení tohoto textového editoru s debuggerem (většinou se zmíněným gdb). My se dnes zaměříme na dvojici pluginů nazvaných Clewn a Pyclewn. První z těchto pluginů dokáže komunikovat s debuggerem gdb, druhý pak i s debuggerem nazvaným pdb používaným pro ladění aplikací naprogramovaných v Pythonu. Předností obou zmíněných pluginů je fakt, že před uživatelem neskrývají způsob komunikace s debuggerem, takže je v případě potřeby možné v debuggeru volat i takové příkazy, které nejsou přímo v pluginu podporovány. To je velká výhoda, protože především gdb je velmi mocným nástrojem, a to zejména ve chvíli, kdy je zapotřebí odladit zákeřné chyby při přístupu do paměti či při špatné koordinaci práce většího množství vláken (dokonce si troufnu tvrdit, že v tomto ohledu debugger gdb překonává většinu komerčních nástrojů).
Obrázek 2: Typické „sezení“ programátora využívajícího debugger gdb. Nastavení breakpointu příkazem b main, spuštění laděného programu příkazem r a krokování příkazem n (klávesa Enter zopakuje poslední zadaný příkaz, proto je n vlastně v tomto příkladu používán nadbytečně).
2. Princip propojení Vimu s debuggery
Před popisem pluginů Clewn a Pyclewn se nejprve seznámíme s možnostmi propojení textového editoru Vim s debuggery. Debugger gdb je možné ovládat několika způsoby. V nejjednodušším případě se z terminálu spustí příkaz gdb, který se interaktivně ovládá příkazy zapisovanými z klávesnice a výstup je prováděn na obrazovku terminálu. Tato možnost je ukázána na obrázku číslo 3.
Obrázek 3: Každý skutečný debugger by měl podporovat disassembling ze strojového kódu popř. z bajtkódu do čitelné podoby (jazyka symbolických instrukcí).
Taktéž je možné použít nějakou nadstavbu nad gdb, například aplikaci nazvanou gdbtui, která je taktéž ovládána z terminálu, ale díky použití knihovny curses či ncurses je možné využít celoobrazovkový výstup a přiblížit se tak možnostem debuggerů s grafickým uživatelským rozhraním. gdbtui je sice zajímavá aplikace, ale kvůli použití klávesových zkratek známých z Emacsu pravděpodobně nebude skalním uživatelům textového editoru Vim příliš vyhovovat :-) (nicméně za odzkoušení určitě stojí). Další možnost spočívá v komunikaci s běžícím debuggerem s využitím protokolu, který je známý a poměrně dobře popsaný. Mohou ho používat různé nástroje, včetně grafických nadstaveb nad gdb.
Obrázek 4: Aplikace gdbtui nabízí „alternativní“ celoobrazovkové ovládání debuggeru.
V pluginu Pyclewn je použita právě tato možnost – debugger se spustí jako samostatný proces, který po své inicializaci otevře port, na němž naslouchá příkazům posílaným z Vimu. Mimochodem – tento způsob práce s debuggerem lze použít i pro ladění aplikace na vzdáleném počítači, popř. na nějaké vývojové desce – Raspberry PI atd. To je v mnoha případech poměrně výhodné, protože zmíněný vzdálený počítač či vývojová deska vůbec nemusí být vybavena klávesnicí a displejem. Pokud vás toto téma zajímá, podrobnosti o různých možnostech použití gdb jsou dostupné na stránkách http://davis.lbl.gov/Manuals/GDB/gdb17.html a http://kegel.com/linux/gdbserver.html, popř. se lze podívat na manuálovou stránku příkazu gdbserver.
Obrázek 5: Aplikace gdbtui nabízí „alternativní“ celoobrazovkové ovládání debuggeru.
3. Funkce Vimu, které jsou používané pluginy spolupracujícími s debuggery
Textový editor Vim ve skutečnosti usnadňuje práci všem tvůrcům pluginů, které mají komunikovat s debuggery, protože jim nabízí tzv. Vim NetBeans Protocol. Název této technologie vychází z toho, že se původně jednalo o rozhraní používané pluginem nazvaným NetBeans pro komunikaci Vimu se známým integrovaným vývojovým prostředím NetBeans. Tento plugin již není vyvíjen (pravděpodobně proto, že se v NetBeans již nedá nastavit integrace s externím editorem – to jsem ale netestoval), ovšem samotný Vim NetBeans Protocol se dobře ujal, je podporován a taktéž používán mnoha dalšími pluginy, a to nikoli pro komunikaci s IDE NetBeans, ale právě při ovládání debuggerů. Ostatně přímo v nápovědě Vimu jsou některé pluginy, které tento protokol používají, vypsány: VimIntegration, Agide, Clewn, Pyclewn, VimPlugin, PIDA a VimWrapper. Co vlastně Vim NetBeans Protocol tvůrcům pluginů nabízí? Především se jedná o podporu oboustranné komunikace, kdy debugger může Vimu poslat zprávu o tom, že se má překreslit obsah nějakého okna (například okna s výpisem sledovaných proměnných), Vim naopak může poslat příkaz debuggeru atd. Bližší informace o této zajímavé a užitečné technologii lze nalézt přímo ve Vimu zadáním příkazu:
:help netbeans
Obrázek 6: Bez podpory této technologie (viz červený obdélník) nebudou mnohé pluginy pracovat korektně! To se týká i dnes popisovaných pluginů.
Další vlastností textového editoru Vim, která se v pluginech pro komunikaci s debuggery (ale nejenom s nimi) používá, je podpora takzvaných značek (signs). Pokud je Vim spuštěný v terminálu, jedná se o textové značky typicky zobrazované na levém okraji okna; tyto značky mohou například ukazovat na právě laděný příkaz, na breakpoint atd. V případě použití Vimu s grafickým uživatelským rozhraním je možné namísto textové značky použít i ikonu, na terminálu se uživatelé musí spokojit s případným barevným vyznačením řádku se značkou. Bližší informace o této technolgoii lze opět nalézt přímo ve Vimu, a to zadáním příkazu:
:help signs
Značky ve skriptech lze vytvářet relativně snadno. Následující dva řádky slouží k definici nové značky nazvané mojeznacka. Tato značka bude zobrazena jako dvě hvězdičky vyobrazené stejnými barvami popředí a pozadí, jaké jsou deklarovány pro lexikální kategorii Error. Samotná značka bude umístěna na levém okraji aktivního okna, konkrétně na sedmém řádku. Symbol 3 reprezentuje identifikátor značky, na nějž je možné se později odkazovat:
:sign define mojeznacka text=** texthl=Error :sign place 3 line=7 name=mojeznacka file=__jmeno_otevreneho_souboru__
Obrázek 7: Takto vypadá značka vytvořená příkazy uvedenými před tímto obrázkem.
4. Plugin Clewn
První plugin, o němž se dnes zmíníme, se jmenuje Clewn. Podle očekávání se jedná o přídavný modul sloužící pro propojení textového editoru Vim s debuggerem, konkrétně s debuggerem gdb (https://www.gnu.org/software/gdb/). Tento plugin umožňuje volat většinu základních příkazů gdb, ovšem způsob kooperace mezi Vimem a gdb, který je v pluginu Clewn implementován, nemusí všem uživatelům vyhovovat – v tomto případě je dobré se podívat na možnosti pluginu Pyclewn popsaného v sedmé kapitole (nechci tvrdit, že Pyclewn je ve všech ohledech lepší, ovšem jeho instalace i ovládání je podle mého názoru jednodušší). Jak vlastně Clewn funguje? Tento plugin obsahuje kromě části psané ve VimScriptu i binární (nativní) část, konkrétně spustitelný program nazvaný clewn, který je nainstalován v adresáři dostupném přes PATH (v případě lokální instalace se většinou jedná o adresář ~/bin). Tento binární program po svém spuštění provede inicializaci debuggeru a následně spuštění Gvimu, tj. Vimu s GUI. Tyto dvě aplikace pak spolu mohou přes clewn komunikovat.
Obrázek 8: Připojení Vimu k debuggeru a nastavení breakpointu na začátek funkce main.
5. Instalace pluginu Clewn
Podívejme se nyní na instalaci pluginu Clewn, kterou lze rozdělit na dvě části – překlad binární utility a instalaci skriptu. Pro překlad binární utility je nutné mít v systému nainstalovány knihovny ncurses-devel a libreadline-devel. Na Fedoře je instalace obou zmíněných knihoven jednoduchá:
sudo yum install ncurses-devel sudo yum install libreadline-devel
Následně stáhneme zdrojové kódy pluginu:
wget -O clewn.tar.gz "http://downloads.sourceforge.net/project/clewn/clewn/clewn-1.15/clewn-1.15.tar.gz?r=http%3A%2F%2Fsourceforge.net%2Fprojects%2Fclewn%2Ffiles%2FOldFiles%2F&ts=1432050333&use_mirror=netcologne"
Ve třetím kroku se rozbalí stažený tarball a provede se známá magická trojice příkazů configure+make+install. Pro instalaci pluginu pro všechny uživatele je nutné mít práva roota:
tar xvfz clewn.tar.gz cd clewn-1.15/ ./configure make make install
Osobně však pro první pokusy doporučuji lokální instalaci pro jednoho uživatele:
tar xvfz clewn.tar.gz cd clewn-1.15/ vimdir=$HOME/.vim ./configure --prefix=$HOME make make install
V tomto případě by se v adresáři ~/bin měl objevit nový spustitelný soubor clewn, což lze snadno ověřit:
ls -l ~/bin total 400 -rwxr-xr-x. 1 tester tester 474 Jan 23 17:58 asciidoctor -rwxr-xr-x. 1 tester tester 479 Jan 23 17:58 asciidoctor-safe -rwxr-xr-x. 1 tester tester 400234 May 19 17:54 clewn
Současně se (alespoň doufejme) nainstaluje i vimovská část pluginu.
Obrázek 9: Krokování programu z Vimu.
6. Použití pluginu Clewn
Ukažme si nyní použití pluginu Clewn při ladění aplikace test.c. Nejprve je nutné přeložit zdrojový kód a přitom překladači přikázat, že se mají do výsledného spustitelného souboru přidat i ladicí informace. V případě programovacího jazyka C je to jednoduché:
gcc -O0 -g -o test test.c
Výsledkem dokončení překladu bude v tomto případě binární spustitelný soubor nazvaný test. Následuje spuštění utility clewn:
clewn -d -ga test
Tento příkaz by měl spustit a inicializovat debugger gdb a současně v novém okně spustit Gvim. Ovládání debuggeru lze provádět přímo z Vimu, v němž se otevře příslušný zdrojový kód (test.c). K dispozici jsou následující klávesové zkratky:
| Klávesová zkratka | Význam |
|---|---|
| R | spuštění programu |
| Q | ukončení ladění |
| Ctrl+B | nastavení breakpointu na řádku s kurzorem |
| Ctrl+E | vymazání breakpointů na řádku s kurzorem |
| B | zobrazení informací o breakpointech |
| S | jeden krok s vykonáním celé volané funkce (step) |
| I | jeden krok s případným vstupem do volané funkce (step into) |
| C | pokračovat ve vykonávání programu (continue) |
| L | zobrazení informací o lokálních proměnných |
| A | zobrazení informací o argumentech |
| W | zobrazení informací, v jakém bodě se program nachází (backtrace) |
Ve skutečnosti existuje ještě více klávesových zkratek, naleznete je v nápovědě k pluginu.
Obrázek 10: Zobrazení nápovědy k pluginu a výpis lokálních proměnných (v debuggeru).
7. Plugin Pyclewn
Druhým pluginem určeným pro propojení textového editoru Vim s debuggerem je přídavný modul nazvaný Pyclewn. Tento plugin umožňuje práci s debuggerem gdb (použijí ho céčkači, vývojáři pracující v C++, Fortranu atd. atd.) a taktéž s debuggerem pdb používaném při ladění aplikací naprogramovaných v Pythonu. Tento plugin nepotřebuje pro svoji práci Gvim spuštěný s GUI, veškerá činnost se odehrává v jediném terminálu a navíc se tento plugin spouští přímo z Vimu (u výše popsaného nástroje to bylo naopak – nejprve se spustil clewn, který následně otevřel nové okno s Gvimem).
Obrázek 11: Integrovaná nápověda k pluginu Pyclewn.
Samotné uživatelské prostředí připravené tímto pluginem (viz přiložené screenshoty) je snadno pochopitelné – jedno okno se používá pro zobrazení konzole debuggeru, další menší okna slouží pro výpis nastavených breakpointů, sledovaných proměnných atd. a poslední část plochy Vimu ukazuje laděný zdrojový kód, v němž jsou s využitím značek zvýrazněny breakpointy, zakázané breakpointy a ve chvíli krokování i právě prováděný prováděný řádek. Plugin mapuje i klávesové zkratky, další zkratky je samozřejmě možné v případě potřeby přidat.
Obrázek 12: Připojování pluginu Pyclewn k debuggeru.
8. Instalace pluginu Pyclewn
Instalace pluginu Pyclewn je poněkud jednodušší, než tomu bylo u dříve popsaného pluginu Clewn, protože při instalaci lze použít známý správce Pythonovských balíčků pip (https://pip.pypa.io/en/stable/. Pokud nemáte pip nainstalovaný ve svém systému, můžete použít instrukce dostupné na stránce https://pip.pypa.io/en/stable/installing.html, kde je celá instalace podrobně popsána. Následně je nutné nainstalovat balíček python-dev. Na operačních systémech založených na RPM lze použít příkaz:
sudo yum install python-dev
Na systémech založených na .deb balíčcích pak příkaz:
sudo apt-get install python-dev
Dále již následuje vlastní instalace binární části pluginu Pyclewn:
pip install --user pyclewn
Posledním krokem je instalace Vimovského pluginu, který je dostupný ve formě takzvaného vim-ballu:
python -c "import clewn; clewn.get_vimball()" vim -S pyclewn-2.1.vmb
Po zadání posledního příkazu se spustí Vim, který sám dokončí instalaci, protože vim-ball obsahuje i instalační skript:
"pyclewn-2.1.vmb" 1900L, 70672C Vimball Archive extracted <autoload/pyclewn/start.vim>: 224 lines wrote /home/tester/.vim/autoload/pyclewn/start.vim extracted <autoload/pyclewn/buffers.vim>: 241 lines wrote /home/tester/.vim/autoload/pyclewn/buffers.vim extracted <autoload/pyclewn/version.vim>: 4 lines wrote /home/tester/.vim/autoload/pyclewn/version.vim extracted <doc/pyclewn.txt>: 1243 lines wrote /home/tester/.vim/doc/pyclewn.txt extracted <plugin/pyclewn.vim>: 11 lines wrote /home/tester/.vim/plugin/pyclewn.vim extracted <syntax/clewn_variables.vim>: 25 lines wrote /home/tester/.vim/syntax/clewn_variables.vim extracted <macros/.pyclewn_keys.gdb>: 49 lines wrote /home/tester/.vim/macros/.pyclewn_keys.gdb extracted <macros/.pyclewn_keys.pdb>: 44 lines wrote /home/tester/.vim/macros/.pyclewn_keys.pdb extracted <macros/.pyclewn_keys.simple>: 38 lines wrote /home/tester/.vim/macros/.pyclewn_keys.simple did helptags
Obrázek 13: Ladění programu napsaného v céčku: nastavení breakpointů, sledování proměnných atd. Povšimněte si, že tento plugin bez problémů pracuje i v terminálu, ovšem je zapotřebí použít větší okno (zde 80×25 znaků je nedostatečných, což je ovšem pochopitelné)
Výsledná struktura adresáře ~/.vim může vypadat následovně. Povšimněte si, že kromě pluginu Pyclewn jsou nainstalovány i další pluginy, především již popsané pluginy Pathogen, vim-diff, vim-slime a matchit:
. ├── autoload │ ├── pathogen.vim │ └── pyclewn │ ├── buffers.vim │ ├── start.vim │ └── version.vim ├── bundle │ ├── vim-dirdiff │ │ ├── doc │ │ │ ├── dirdiff.txt │ │ │ └── tags │ │ ├── plugin │ │ │ └── dirdiff.vim │ │ ├── README.md │ │ └── screenshot.png │ └── vim-slime │ ├── doc │ │ ├── tags │ │ └── vim-slime.txt │ ├── ftplugin │ │ ├── coffee │ │ │ └── slime.vim │ │ ├── fsharp │ │ │ └── slime.vim │ │ ├── haskell │ │ │ └── slime.vim │ │ ├── lhaskell │ │ │ └── slime.vim -> ../haskell/slime.vim │ │ ├── ocaml │ │ │ └── slime.vim │ │ ├── python │ │ │ └── slime.vim │ │ └── scala │ │ └── slime.vim │ ├── LICENSE.txt │ ├── plugin │ │ └── slime.vim │ └── README.md ├── doc │ ├── matchit.txt │ ├── pyclewn.txt │ └── tags ├── macros ├── plugin │ ├── matchit.vim │ └── pyclewn.vim ├── spell │ ├── cs.iso-8859-2.spl │ ├── cs.utf-8.add │ ├── cs.utf-8.add.spl │ └── cs.utf-8.spl └── syntax └── clewn_variables.vim
Obrázek 14: Ladění programu napsaného v céčku: ukončení laděného programu. V horním okně můžeme vidět rozhraní debuggeru gdb, v prostředním okně breakpointy, sledované proměnné atd., ve spodním okně pak laděný zdrojový kód.
9. Použití pluginu Pyclewn
V případě, že se plugin Pyclewn používá pro ladění s využitím debuggeru gdb, stačí přeložit příslušný zdrojový kód a přitom překladači přikázat, že se mají do výsledného spustitelného souboru přidat i ladicí informace. V případě programovacího jazyka C je to jednoduché:
gcc -O0 -g -o test test.c
Výsledkem dokončení překladu bude v tomto případě binární spustitelný soubor nazvaný test (pokud máte správně nastavené cesty, nedojde ke kolizi s existujícím příkazem stejného jména :-). Následně se spustí Vim, v němž se otevře zdrojový soubor:
vim test.c
Ve Vimu se příkazem:
:pyclewn gdb
spustí debugger a plugin se k debuggeru připojí. Plugin následně rozdělí okno editoru na pět podoken (viz screenshoty) a v horním podokně zobrazí konzoli debuggeru. Následně se musí do debuggeru nahrát laděný binární soubor:
:Cfile test
Obrázek 15: Ladění programu napsaného v Pythonu: připojení k debuggeru.
Nyní by již vše mělo být připraveno na otestování funkcí nabízených pluginem Pyclewn. Všechny příkazy začínají velkým písmenem C, za nímž následuje jméno příkazu, který (většinou) odpovídá stejnojmennému příkazu v gdb. Podívejme se nyní na několik nejpoužívanějších příkazů:
Nastavení breakpointu na začátek funkce main (breakpoint se objeví v příslušném podokně – prvním podokně ve druhé sekci):
:Cbreak main
Spuštění laděného programu:
:Crun
Laděný program se (podle očekávání) zastaví na prvním příkazu ve funkci main, protože právě zde jsme nastavili breakpoint. Pro provedení tohoto příkazu – jednoho kroku – poslouží příkaz:
:Cstep
Nastavit lze samozřejmě i watchpointy hlídající přístup k proměnné či k několika proměnným (informace o nastavených watchpointech se opět zapíše do pomocného informačního podokna):
:Cwatch x,y,answer
Pro zobrazení obsahu proměnné či proměnných poslouží příkaz (otevře se další podokno se seznamem a aktuálním obsahem všech sledovaných proměnných, změněná proměnná je v každém kroku vysvícena, což je velmi užitečné):
:Cdbgvar x
Popř. je možné sledovat i výrazy:
:Cdbgvar x*10
Další možnosti použití tohoto pluginu, včetně možnosti namapování klávesových zkratek, si v případě čtenářského zájmu popíšeme příště.
Obrázek 16: Ladění programu napsaného v Pythonu: krokování a zobrazení nápovědy k pluginu Pyclewn.
10. Odkazy na předchozí části článku
- Užitečné skripty a pluginy pro textový editor Vim
http://www.root.cz/clanky/uzitecne-skripty-a-pluginy-pro-textovy-editor-vim/ - Užitečné skripty a pluginy pro textový editor Vim (2.část)
http://www.root.cz/clanky/uzitecne-skripty-a-pluginy-pro-textovy-editor-vim-2-cast/ - Užitečné skripty a pluginy pro textový editor Vim (3.část)
http://www.root.cz/clanky/uzitecne-skripty-a-pluginy-pro-textovy-editor-vim-3-cast/ - Užitečné skripty a pluginy pro textový editor Vim (4.část)
http://www.root.cz/clanky/uzitecne-skripty-a-pluginy-pro-textovy-editor-vim-4-cast/ - Užitečné skripty a pluginy pro textový editor Vim (5.část)
http://www.root.cz/clanky/uzitecne-skripty-a-pluginy-pro-textovy-editor-vim-5-cast/ - Užitečné skripty a pluginy pro textový editor Vim (6.část)
http://www.root.cz/clanky/uzitecne-skripty-a-pluginy-pro-textovy-editor-vim-6-cast-cestovani-v-case/ - Užitečné skripty a pluginy pro textový editor Vim (7.část)
http://www.root.cz/clanky/uzitecne-skripty-a-pluginy-pro-textovy-editor-vim-7-cast/ - Tvorba vlastního pluginu pro textový editor Vim
http://www.root.cz/clanky/tvorba-vlastniho-pluginu-pro-textovy-editor-vim/
11. Odkazy na Internetu
- Pyclewn installation notes
http://pyclewn.sourceforge.net/install.html - pip Installation
https://pip.pypa.io/en/latest/installing.html - Clewn
http://clewn.sourceforge.net/ - Clewn installation
http://clewn.sourceforge.net/install.html - Clewn – soubory
http://sourceforge.net/projects/clewn/files/OldFiles/ - Writing Vim Plugins
http://stevelosh.com/blog/2011/09/writing-vim-plugins/ - how to understand this vim script?
http://stackoverflow.com/questions/12625091/how-to-understand-this-vim-script - Novinky ve VIM 7: Skriptovací jazyk
http://www.root.cz/vim-sedm-druha-cast/ - DirDiff.vim : A plugin to diff and merge two directories recursively.
http://www.vim.org/scripts/script.php?script_id=102 - vim-dirdiff na GitHubu
https://github.com/will133/vim-dirdiff - fakeclip : pseudo clipboard register for non-GUI version of Vim
http://www.vim.org/scripts/script.php?script_id=2098 - vim-fakeclip na GitHubu
https://github.com/kana/vim-fakeclip - vim-fakeclip: Dokumentace
http://kana.github.io/config/vim/fakeclip.html - Vim Multiple Cursors na GitHubu
https://github.com/terryma/vim-multiple-cursors - SLIME (Wikipedia)
http://en.wikipedia.org/wiki/SLIME - vim-slime na GitHubu
https://github.com/jpalardy/vim-slime - vi Editor Commands
http://www.cs.rit.edu/~cslab/vi.html#A1.4 - vi Manual
http://www.cs.fsu.edu/general/vimanual.html - Mastering the Vi Editor
http://www.susnet.uk/mastering-the-vi-editor - Using undo branches
http://vim.wikia.com/wiki/Using_undo_branches - Gundo
http://sjl.bitbucket.org/gundo.vim/ - Vim as a Python IDE, or Python IDE as Vim
http://blog.jetbrains.com/pycharm/2013/06/vim-as-a-python-ide-or-python-ide-as-vim/ - histwin na GitHubu
https://github.com/chrisbra/histwin.vim - histwin.vim : Browse the undo tree
http://www.vim.org/scripts/script.php?script_id=2932 - undotree.vim : Display your undo history in a graph
http://www.vim.org/scripts/script.php?script_id=4177 - Surround
http://www.bestofvim.com/plugin/surround/ - SnipMate
http://www.bestofvim.com/plugin/snipmate/ - Getting a Clojure REPL in Vim With VimClojure, Nailgun, and Leiningen
http://naleid.com/blog/2011/12/19/getting-a-clojure-repl-in-vim-with-vimclojure-nailgun-and-leiningen/ - The NERD Commenter : A plugin that allows for easy commenting of code for many filetypes.
http://www.vim.org/scripts/script.php?script_id=1218 - NERD Commenter na GitHubu
https://github.com/scrooloose/nerdcommenter - luarefvim : Lua reference manual
http://www.vim.org/scripts/script.php?script_id=1291 - lua.vim : Lua file type plug-in for the Vim text editor
http://www.vim.org/scripts/script.php?script_id=3625 - vim-lua-ftplugin
https://github.com/xolox/vim-lua-ftplugin - Vi Improved
https://wiki.python.org/moin/Vim - javacomplete : Omni Completion for JAVA
http://www.vim.org/scripts/script.php?script_id=1785 - SearchComplete
http://www.vim.org/scripts/script.php?script_id=474 - ShowMarks
http://www.vim.org/scripts/script.php?script_id=152 - ctrlp.vim
https://github.com/kien/ctrlp.vim - ctrlp.vim
http://kien.github.io/ctrlp.vim/ - vim-signature
https://github.com/kshenoy/vim-signature - Supertab
http://www.vim.org/scripts/script.php?script_id=1643 - Supertab (GitHub)
https://github.com/ervandew/supertab - Vim Essential Plugin: NERD Tree
http://code.tutsplus.com/tutorials/vim-essential-plugin-nerdtree–net-19692 - The NERD tree : A tree explorer plugin for navigating the filesystem
http://vim.sourceforge.net/scripts/script.php?script_id=1658 - NERD Tree Guide
http://usevim.com/2012/07/18/nerdtree/ - vcscommand.vim : CVS/SVN/SVK/git/hg/bzr integration plugin
http://www.vim.org/scripts/script.php?script_id=90 - vcscommand na GitHubu
https://github.com/vim-scripts/vcscommand.vim - Popis skriptu Vim Pathogen
http://www.vim.org/scripts/script.php?script_id=2332 - Posledníverze skriptu Vim Pathogen
https://tpo.pe/pathogen.vim - Nejlepší pluginy pro Vim
http://vimawesome.com/ - Nejlepší pluginy pro Vim
http://www.vim.org/scripts/script_search_results.php?order_by=rating - Vim-airline na GitHubu
https://github.com/bling/vim-airline - Vim-airline na www.vim.org
http://www.vim.org/scripts/download_script.php?src_id=22726 - Vim-fugitive na GitHubu
https://github.com/tpope/vim-fugitive - Vim-fugitive na www.vim.org
http://www.vim.org/scripts/script.php?script_id=2975 - Textový editor Vim jako IDE (seriál)
http://www.root.cz/clanky/textovy-editor-vim-jako-ide/ - Building Vim
http://vim.wikia.com/wiki/Building_Vim - Getting the Vim source with Mercurial
http://vim.wikia.com/wiki/Getting_the_Vim_source_with_Mercurial - Vim Perl Interface
http://vim.dindinx.net/vim7/html/if_perl.txt.php - Vim Perl Support
http://www.softpanorama.org/Editors/Vimorama/vim_perl_support.shtml - VIM as Python IDE
http://blog.dispatched.ch/2009/05/24/vim-as-python-ide/ - Stack Overflow: VIM: Perl interface: passing a variable to Perl and reading a vim variable from Perl
http://stackoverflow.com/questions/4999902/vim-perl-interface-passing-a-variable-to-perl-and-reading-a-vim-variable-from - Stack Overflow: Getting started with vim scripting with Perl
http://stackoverflow.com/questions/2208618/getting-started-with-vim-scripting-with-perl - Python with a modular IDE (Vim)
http://www.sontek.net/python-with-a-modular-ide-vim - Getting to VIM's Python interface
http://zerokspot.com/weblog/2009/02/21/getting-to-know-vims-python-interface/ - Pretty-formatting XML
http://vim.wikia.com/wiki/Pretty-formatting_XML - Delete a pair of XML/HTML tags
http://vim.wikia.com/wiki/Delete_a_pair_of_XML/HTML_tags - Vim as XML Editor
http://www.pinkjuice.com/howto/vimxml/ - xmledit: A filetype plugin to help edit XML, HTML, and SGML documents
http://www.vim.org/scripts/script.php?script_id=301 - Poslední vývojová verze makra xmledit
http://github.com/sukima/xmledit/ - vim.wikia: Display date-and-time on status line
http://vim.wikia.com/wiki/Display_date-and-time_on_status_line - vim.wikia: Writing a valid statusline
http://vim.wikia.com/wiki/Writing_a_valid_statusline - vim.wikia: Statusline tab level ruler
http://vim.wikia.com/wiki/Statusline_tab_level_ruler - vim.wikia: Switching between different statuslines
http://vim.wikia.com/wiki/Switching_between_different_statuslines - X Selections, Cut Buffers, and Kill Rings
http://www.jwz.org/doc/x-cut-and-paste.html - Accessing the system clipboard
http://vim.wikia.com/wiki/Accessing_the_system_clipboard - xcutsel(1) – Linux man page
http://linux.die.net/man/1/xcutsel - snipMate : TextMate-style snippets for Vim
http://www.vim.org/scripts/script.php?script_id=2540 - msanders / snipmate.vim
https://github.com/msanders/snipmate.vim - snipMate.vim Introductory Screencast
http://vimeo.com/3535418 - 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/ - vim (man page)
http://www.linux-tutorial.info/modules.php?name=ManPage&sec=1&manpage=vim - 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/ - 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 - Vim plugins for developers
http://www.linuxtoday.com/upload/vim-plugins-for-developers-140619094010.html
