Vim [compiler et] exécuter le raccourci

http://singlecompile.topbug.net semble faire plus que ce que vous voulez. Pour une solution plus simple, vous pouvez aussi ajouter ce qui suit à votre vimrc

au BufEnter *.cpp set makeprg=g++\ -g\ %\ -o\ %< 
au BufEnter *.c set makeprg=gcc\ -g\ %\ -o\ %< 
au BufEnter *.py set makeprg=python\ % 
au BufEnter *.[rR] set makeprg=Rscript\ %
map <F5> :call CompileGcc()<CR>
func! CompileGcc()
    exec "w" 
    silent make
endfunc

HTH

on est en 2018 maintenant, vim 8 est sorti depuis 2 ans et est livré avec toutes les distributions Linux mean stream et Mac OS X. Mais beaucoup de tutoriels vim enseignent encore aux gens quelque chose il y a 10 ans.

vous pouvez compiler vos programmes C++/Java dans vim aussi facilement que Sublime Text ou NotePad++ avec quelques plugins dédiés pour Vim 8 ou NeoVim.

Par exemple, AsyncRun le plugin vous permettra d'exécuter des commandes shell en arrière-plan et de lire la sortie de la fenêtre quickfix en temps réel. Voir la capture d'écran.

tout comme la compilation de programmes dans IDEs, les erreurs de compilation seront appariées par errorformat et seront surlignées et deviennent sélectionnables. Vous pouvez naviguer dans les erreurs dans la fenêtre quickfix ou continuer à éditer pendant la compilation.

installation Rapide

copier et coller les lignes ci-dessous à votre vimrc:

Plug 'skywind3000/asyncrun.vim'

" open quickfix window automatically when AsyncRun is executed
" set the quickfix window 6 lines height.
let g:asyncrun_open = 6

" ring the bell to notify you job finished
let g:asyncrun_bell = 1

" F10 to toggle quickfix window
nnoremap <F10> :call asyncrun#quickfix_toggle(6)<cr>

lorsque vous entrez": asyncrun echo hello " dans la ligne de commande:

voir la capture ici

vous verrez la sortie de commande en temps réel dans la fenêtre Ouvrir quickfix.

Compiler et exécuter un seul fichier

compiler un seul fichier avec AsyncRun est beaucoup plus simple que le système de compilation de Sublime Text. Nous pouvons configurer F9 pour cela:

noremap <silent> <F9> :AsyncRun gcc -Wall -O2 "$(VIM_FILEPATH)" -o "$(VIM_FILEDIR)/$(VIM_FILENOEXT)" <cr>

Les macros $(..) formulaire sera élargi le vrai nom de fichier ou de répertoire, et alors nous aurons F5 pour exécuter l'exécutable:

noremap <silent> <F5> :AsyncRun -raw -cwd=$(VIM_FILEDIR) "$(VIM_FILEDIR)/$(VIM_FILENOEXT)" <cr>

le double guillemet est utilisé pour traiter les noms de chemin contenant des espaces. L'option -cwd=$(VIM_FILEDIR) moyens d'exécuter le fichier dans le répertoire du fichier. Le chemin d'accès absolu $(VIM_FILEDIR)/$(VIM_FILENOEXT) est utilisé parce que linux a besoin d'un ./ préfixe pour exécuter des exécutables dans le répertoire courant, mais windows ne le fait pas . En utilisant le nom de chemin absolu du fichier binaire peut gérer ce problème de plateforme de croisement.

une autre option -raw signifie la sortie ne sera pas égalé par l'errorformat de vim, et sera affiché dans quickfix comme ce qu'il est. Vous pouvez maintenant compiler votre fichier avec F9, vérifier les erreurs de compilation dans la fenêtre quickfix et appuyer sur F5 pour exécuter le binaire.

Construire Des Projets C/C++

peu importe l'outil de compilation que vous utilisez, make ou cmake, project building signifie agir sur un groupe de fichiers. Il faut trouver le répertoire racine du projet. AsyncRun utilise une méthode simple appelée marqueurs de racine pour identifier la racine du projet. La Racine du Projet est identifié comme l'ancêtre le plus proche répertoire d'un fichier qui contient l'un de ces répertoires ou les fichiers:

let g:asyncrun_rootmarks = ['.svn', '.git', '.root', '_darcs'] 

si aucun des répertoires parent ne contient ces repères racine, le répertoire du fichier courant est utilisé comme racine du projet. Cela nous permet d'utiliser <root> ou $(VIM_ROOT) pour représenter la racine du projet. et F7 peut être configuré pour construire le projet en cours:

noremap <silent> <F7> :AsyncRun -cwd=<root> make <cr>

et si votre le projet actuel n'est pas dans un dépôt git ou subversion ? Comment savoir où est ma racine du projet ? La solution est très simple, il suffit de mettre un vide .le fichier racine dans votre racine de projet, il sera localisé facilement.

allons de l'avant, installez F8 pour exécuter le projet en cours:

noremap <silent> <F8> :AsyncRun -cwd=<root> -raw make run <cr>

Le projet sera exécuté dans son répertoire racine. Bien sûr, vous devez définir la règle run dans votre propre makefile. puis reconfigurer F6 pour tester:

noremap <silent> <F6> :AsyncRun -cwd=<root> -raw make test <cr>

si vous utilisez cmake, F4 peut être map pour mettre à jour votre Makefile:

nnoremap <silent> <F4> :AsyncRun -cwd=<root> cmake . <cr>

en raison de l'implémentation de C runtime, si le processus est exécuté dans un environnement non-tty, toutes les données de stdout seront mises en mémoire tampon jusqu'à la sortie du processus. Donc, il doit y avoir un fflush(stdout) après printf si vous voulez voir l'affichage en temps réel. ou vous pouvez fermer le tampon stdout au début par

setbuf(stdout, NULL);

en attendant, si vous écrivez du code C++, une std:: endl peut être ajoutée à la fin de std:: Cut. Il peut forcer la purge du tampon stdout. Si vous développez sur windows, AsyncRun peut ouvrir une nouvelle fenêtre cmd pour le processus enfant:

nnoremap <silent> <F5> :AsyncRun -cwd=$(VIM_FILEDIR) -mode=4 "$(VIM_FILEDIR)/$(VIM_FILENOEXT)" <cr>
nnoremap <silent> <F8> :AsyncRun -cwd=<root> -mode=4 make run <cr>

en utilisant l'option -mode=4 sur windows ouvrira une nouvelle fenêtre d'invite pour exécuter la commande, tout comme pour exécuter des programmes en ligne de commande dans Visual Studio. Enfin, nous avons ces mappages clés ci-dessous:

• F4: mise à jour du Makefile avec cmake.
• F5: exécutez le fichier unique
• F6: exécuter le projet test
• F7: projet de construction d'
• F8: exécution de projet
• F9: compiler le fichier unique
• F10: bascule quickfix window

c'est plus comme construire un système dans NotePad++ et GEdit. Si vous utilisez cmake lourdement, vous pouvez écrire un script shell simple situé dans ~/.vim/script/build.sh pour combiner F4 et F7 ensemble: il mettra à jour le Makefile si CMakeList.txt a été modifié, puis execute make.

Avancé utilisation

vous pouvez également définir des scripts shell dans votre dépôt dotfiles et exécuter le script avec F3:

nnoremap <F3> :AsyncRun -cwd=<root> sh /path/to/your/dotfiles/script/build_advanced.sh <cr>

les variables d'environnement shell suivantes sont définies par AsyncRun:

$VIM_FILEPATH  - File name of current buffer with full path
$VIM_FILENAME  - File name of current buffer without path
$VIM_FILEDIR   - Full path of current buffer without the file name
$VIM_FILEEXT   - File extension of current buffer
$VIM_FILENOEXT - File name of current buffer without path and extension
$VIM_CWD       - Current directory
$VIM_RELDIR    - File path relativize to current directory
$VIM_RELNAME   - File name relativize to current directory 
$VIM_ROOT      - Project root directory
$VIM_CWORD     - Current word under cursor
$VIM_CFILE     - Current filename under cursor
$VIM_GUI       - Is running under gui ?
$VIM_VERSION   - Value of v:version
$VIM_COLUMNS   - How many columns in vim's screen
$VIM_LINES     - How many lines in vim's screen
$VIM_SVRNAME   - Value of v:servername for +clientserver usage

Toutes les variables d'environnement peuvent être utilisés dans votre build_advanced.sh. L'utilisation du fichier script shell externe peut faire un travail plus complexe qu'une seule commande.

symboles Grep

Parfois, Si vous ne pas avoir un environnement de configuration bien dans votre boîte linux à distance, grep est le moyen le plus bon marché pour rechercher la définition de symbole et les références parmi les sources. Maintenant, nous aurons F2 pour rechercher mot clé sous curseur:

if has('win32') || has('win64')
    noremap <F2> :AsyncRun! -cwd=<root> grep -n -s -R <C-R><C-W> --include='*.h' --include='*.c*' '<root>' <cr>
else
    noremap <F2> :AsyncRun! -cwd=<root> findstr /n /s /C:"<C-R><C-W>" "\%CD\%\*.h" "\%CD\%\*.c*" <cr>
endif

le script ci-dessus lancera grep ou findstr dans le répertoire racine de votre projet, et ne trouvera des symboles que dans .c,.cpp et .h fichiers. Maintenant nous nous déplaçons autour du curseur et appuyez sur F2, les références des symboles dans le projet en cours seront affichées dans la fenêtre quickfix immédiatement.

ce simple keymap suffit pour la plupart du temps. Et vous pouvez améliorer ce script pour supporter plus de types de fichiers ou d'autres outils grep dans votre vimrc .

C'est la façon pratique de construire/exécuter des projets C/C++ dans Vim 8 ou NeoVim. Tout comme le système de compilation de Sublime Text et le NppExec de NotePad++.

plus de tutoriels vim dépassés, essayez quelque chose de nouveau.

voici ma carte ça marche vraiment vous pouvez la mettre à jour dans n'importe quelle langue:

" <!----------------------------" gcc compile C files----------------------------------------!>
autocmd filetype c nnoremap <Leader>c :w <CR>:!gcc % -o %:r && ./%:r<CR>

" <!----------------------------" java compile files----------------------------------------!>
autocmd filetype java nnoremap <Leader>c :w <CR>:!javac % :r&& java %:r<CR>
" <!----------------------------" php compile files----------------------------------------!>
autocmd filetype php nnoremap <Leader>c :w <CR>:!clear && php  %<CR>

maintenant, si vous êtes dans l'un de ces fichiers en vim, faites-le en mode normal:

<leader>c