Artikel mit Schlagwort "Texteditor"

vim komfortabel beenden mit MyQuit

Die Situation kennt vielleicht der ein oder andere vim-Nutzer: Man editiert an mehreren Dateien, schließt und öffnet sie. Leicht verliert man den Überblick, ob man nun mit :wq (also mit speichern) oder nur mit :q vim beenden soll. Hinzu kommt der Umstand, dass man sich im Kommandomodus befinden und den jeweiligen Befehl erst eingeben muss.
Spontan kam mir der Gedanke: Das geht doch bestimmt viel komfortabler.
Und so habe ich mich an ein Script gegeben, was das Beenden von vim viel einfacher und schneller gestaltet. Dabei handelt es sich um eine Funktion, die mit Mapping auf eine Taste gelegt wird.
Wird diese Taste betätigt, überprüft das Script, ob an der geöffneten Datei Änderungen vorgenommen wurden. Existiert die Datei und wurde sie nicht verändert, wird vim sofort geschlossen (:q). Falls es Änderungen gab, wird nun abgefragt, ob diese abgespeichert werden sollen. Ist das nicht der Fall, wird vim wiederum sofort geschlossen (:q!). Sollen die Änderungen gespeichert werden, wird noch überprüft, ob es sich um eine existierende Datei handelt (:wq) oder ob sie neu angelegt werden muss. Muss die Datei erstellt werden, wird man nach dem gewünschten Dateinamen gefragt (:wq $dateiname).

Die Vorteile des Scripts liegen auf der Hand: Es reagiert auf die jeweilige Situation um vim möglichst effizient und schnell zu beenden. Im Vergleich zum herkömmlichen Beeden muss man nicht mehr den jeweils richtigen Befehl eingeben. Es braucht auch nur eine einzige Tastenkombination in das Mapping eingetragen werden (ein Tastendruck für das Beenden).

"""""""""""""""""""""""""""""""""""""""""""""""
" myquit.vim
" Author: Julian <julian@tuxoid.net>
" URL: http://www.tuxoid.net/stuff/myquit.vim
" Version: 1.0 - Mi 8. Sep 11:37:31 CEST 2010
" License: CC 3.0 BY-NC-SA
"""""""""""""""""""""""""""""""""""""""""""""""
 
"""""""""""""""""""""""""""""""""""""""""""""""
" Installation:
" 1) copy myquit.vim to ~/.vim/scripts
" 2) edit .vimrc and insert:
"		:so $HOME/.vim/scripts/myquit.vim
"		map <F8> :call MyQuit()<CR>
"""""""""""""""""""""""""""""""""""""""""""""""
 
 
function! MyQuit()
"	file modified / not stored yet
	if(&modified == 1) 
"		should the file be saved or not?"
		let inp = input('save current file? (y)es/(n)o: ')
"		save file
		if(inp == "y") 
"			file already exists
			if(expand('%:p') != "") 
				exec "wq"
"			file doesn't exist, ask for filename
			else 
				let fname = input('filename: ')
				exec "wq" fname
			endif
"		don't save file => quit immediately
		elseif(inp == "n") 
			exec "q!"
		endif
"	file not modified => quit immediately
	else 
		exec "q"
	endif
endfunction

Die aktuellste Version des Scripts ist unter tuxoid.net/stuff/myquit.vim zu finden!

Das Script kann nun an einen beliebigen Ort kopiert werden. Ich habe es unter ~/.vim/scripts abgelegt. In der .vimrc macht man nun noch folgende Angaben, um das Script einzubinden und die Taste zu belegen:

:so $HOME/.vim/scripts/myquit.vim
map <F8> :call MyQuit()<CR>

Würde mich sehr über Feedback freuen.

C programmieren mit vim

Mit vim, dem vielseitigen und hoch konfigurierbaren Editor, kann man sich auch sehr einfach eine kleine IDE für C bauen. Ziel ist es den geschriebenen Quellcode direkt in vim zu kompilieren und auszuführen. Dazu ist nur ein wenig Konfigurationsarbeit in der vimrc nötig.
Zunächst macht man Angaben zum Compiler:
Falls der Dateityp auf .c endet (autocmd Filetype c), soll bei Eingabe von “:make” folgender Befehl ausgeführt werden: gcc dateiname.c -o dateiname. Der Eintrag in der vimrc sieht wie folgt aus:

autocmd FileType c 		let &makeprg='gcc % -o %<'

Das % steht hierbei für den Dateinamen mit der Dateiendung und das %< für den Dateinamen alleine.
Desweiteren ist es hilfreich die Fehlerausgaben des Compilers sich besser lesbar ausgeben zu lassen (hier: Datei:Zeile:Spalte:Meldung):

let &errorformat='%f:%l:%c:%m'

Nun zu der eigentlichen Konfigurierung:
Im folgenden werden zwei Funktionen definiert. Die erste speichert beim Aufruf die Datei (:w) und kompiliert den Quellcode (:make). Die zweite Funktion macht zunächst das gleiche, führt aber anschließend die kompilierte Datei aus (:!./dateiname).

func! _gcc()
	exec "w"
	exec "make"
endfunc
func! _gccs()
	exec "w"
	exec "make"
	exec "! ./%<"
endfunc

Nun werden noch beide Aufrufe der Funktionen auf eine beliebiger Taste gelegt (Mapping). Hier lege ich sie auf die Tasten F3 und F4, wobei nmap bedeutet, dass dieses Mapping nur für den Normalmodus/Kommandomodus gültig ist.

nmap <F3> :call _gcc()<CR>
nmap <F4> :call _gccs()<CR>

Und was ohnehin in jede vimrc hinein gehört, um die Syntax farblich hervorzuheben (syntax highlighting):

syntax on

Über ein Addon/Script kann man sich dann noch die Projektdateien in einer Art Dateibrowser anzeigen lassen. Es nennt sich sinnvollerweise project.
Damit man im Quellcode steht den Überblick behält unterstützt vim auch das Falten (Folding), womit sich geklammerte Terme ausblenden lassen. Das ist aber wiederum so umfangreich, dass ich hier in diesem Artikel nicht weiter darauf eingehen möchte. Eine gute Anlaufstelle ist, wie immer, die Hilfe (:help folding).

Da vim so unglaublich variabel ist, lässt er nahezu keine Wünsche offen und die oben beschriebene “IDE” ist nur eine von vielen Möglichkeiten.