C editing with VIM HOWTO

2.1. I tasti "w", "e" e "b"

Per spostarsi all'interno dei file si possono usare i tasti w, e e b. VIM è in grado di riconoscere i vari componenti delle espressioni C.

Considerate il seguente codice C

		  ...
		  if(( NULL == x ) && y > z )
		  ...
	       

Considerate che il cursore sia posizionato all'inizio dell'espressione if. Premendo "w" una volta, il cursore salterà al primo (. Premendo ancora w il cursore si sposterà su NULL, quindi su ==. Le pressioni seguenti del tasto vi porteranno a x... )... &&... y... >... z... e alla fine )...

e è simile a w, solo che vi porta alla fine della parola corrente e non all'inizio della seguente.

b fa esattamente l'opposto di w: sposta il cursore nella direzione opposta, dunque potete muovervi all'indietro usando il tasto b.

2.2. I tasti {, }, [[ e ]]

I tasti { e } vengono usati per spostarsi da un paragrafo ad un altro. Quando scrivete file C, questi tasti hanno un significato leggermente differente: un paragrafo rappresenta un gruppo di righe separate da una riga vuota.

Ad esempio

Il ritaglio qua sopra rappresenta due paragrafi. E' possibile muoversi dall'inizio di uno all'altro, usando i tasti { e }. { porterà il cursore al paragrafo superiore e } lo sposterà a quello inferiore.

Molte persone usano uno stile di creazione del codice per il quale un insieme logico di espressioni viene raggruppato insieme e separato da una o più righe vuote.

Ad esempio

I tasti { e } sono molto utili in queste situazioni. E' possibile muoversi da un "paragrafo" all'altro.

Un altro gruppo di tasti utili sono [[ e ]], che vi permettono di saltare alla precedente { o alla seguente { nella prima colonna.

Ad esempio

Diciamo che state lavorando su foo() e ora volete modificare bar(). Semplicemente digitate ]] ed il cursore vi porterà alla { di apertura della funzione bar(). L'inverso è leggermente differente. Se siete nel mezzo di bar() e digitate [[, il cursore si sposterà alla prima { precedente, cioè all'inizio di bar() stessa. Per spostarsi all'inizio di foo() serve ancora [[. Il numero di pressioni dei tasti può essere minimizzato digitando 2[[per portare il cursore all'inizio della funzione precedente.

Altri insiemi di tasti simili sono ][ e []: ][ porta il cursore alla successiva } nella prima colonna. Se state modificando foo() e volete andare alla fine di foo() allora ][ vi porterà lì. In maniera simile se state modificando bar() e volete andare alla fine di foo() allora [] porterà lì il cursore.

Il modo per ricordarsi tutte le combinazioni è spezzarle. Il primo tasto indica se il cursore deve muoversi su o giù: [ andrà su e ] andrà giù. Il seguente indica il tipo di parentesi da cercare. Se è lo stesso tasto allora il cursore si muoverà alla {. Se il tasto è differente allora il cursore andrà a }.

Una cosa a cui fare attenzione per i tasti ]], ][, [[ e [], è che essi cercano le parentesi sulla prima colonna; se si vogliono ricercare tutte le parentesi sopra o sotto indipendentemente dal fatto che siano o no nella prima colonna non lo si può fare. La documentazione di VIM riporta un metodo per aggirare tutto questo: bisogna associare la pressione dei tasti alle parentesi. Per non farvi sprecare troppo tempo nella ricerca dell'associazione, quelle suggerite sono

:map [[ ?{<CTRL-VCTRL-M>w99[{

:map ][ /}<CTRL-VCTRL-M>b99]}

:map ]] j0[[%/{<CTRL-VCTRL-M>

:map [] k$][%?}<CTRL-VCTRL-M>

2.3. Tasto %

Il tasto % cerca un corrispondente all'oggetto sotto il cursore. L'oggetto sotto il cursore può essere una parentesi tonda, una graffa o una quadra. Premendo il tasto % il cursore salterà al corrispondente.

Tra le altre cose, il tasto % può essere anche per accoppiare #if, #ifdef, #else #elif e #endif.

Questo tasto è molto utile nel controllo del codice che è stato scritto. Ad esempio

Controllare il codice qua sopra implica il controllo della correttezza delle parentesi. Il % può essere usato per saltare da una ( alla sua corrispondente ) e viceversa; inoltre, potete scoprire quale parentesi aperta corrisponde a un'altra chiusa ed usare l'informazione per controllare il codice.

In maniera simile il % può essere usato per saltare da una { alla sua } corrispondente.

3.1. ctags

Un tag è una specie di segnaposto. I tag sono molto utili nella comprensione e nella creazione di codice C: sono un insieme di segnalibro per ogni funzione di un file C e sono molto utili per saltare alla definizione di una funzione dal punto dove essa viene richiamata e per ritornare al punto di partenza.

Prendiamo l'esempio seguente.

Diciamo che state lavorando sulla funzione foo() e capitate sulla funzione bar(). Ora, per vedere cosa fa bar(), si fa uso dei tag. Si può saltare alla definizione di bar() e poi saltare di nuovo indietro. Se necessario, si può saltare ad un'altra funzione richiamata dentro bar() e ancora indietro.

Per usare i tag si deve prima eseguire il programma ctags su tutti i file sorgenti. Questo crea un file chiamato tags, che contiene dei puntatori a tutte le definizioni di funzione e viene usato da VIM per portarvi alla definizione corretta.

Le combinazioni di tasti per saltare avanti e indietro sono CTRL-] e CTRL-T. La pressione di CTRL-] nel punto dove viene richiamata bar() porta il cursore all'inizio di bar(). Si può saltare indietro da bar() a foo() semplicemente premendo CTRL-T.

ctags viene richiamato con

	    $ ctags opzioni file
	 

Per creare un file "tags" da tutti i file .c nella directory attuale basta questo comando:

	    $ ctags *.c
	 

Nel caso di un albero dei sorgenti che contenga file C in differenti sottodirectory, si può richiamare ctags in quella che è la radice del codice con l'opzione -R e verrà creato un file "tags" contenente i tag di tutte le funzioni nell'albero del codice. Ad esempio

	    $ ctags -R *.c
	 

Con ctags si possono usare molte altre opzioni, che vengono spiegate nel pagina di man di ctags.

3.2. Marcatori

I marcatori sono una sorta di segnaposto come i tag, ma possono essere collocati in ogni punto di un file e non sono limitati solo a funzioni, elenchi ecc. Inoltre i marcatori devono essere impostati manualmente dall'utente.

Impostando un marcatore non si ha nessuna indicazione dello stesso. Un marcatore è solo una posizione in un file che verrà ricordata da VIM. Considerate il seguente codice:

Supponete che state modificando la riga x++; e volete tornare a quella riga dopo averne modificate altre. Potete impostare un marcatore su quella riga con la combinazione di tasti m' e poi tornarvi con ''.

VIM vi permette di impostare più di un marcatore. Questi marcatori vengono immagazzinati in certi registri, a-z, A-Z e 1-0. Per impostare un marcatore ed immagazzinarlo in un registro, ad esempio j, tutto quello che dovete fare è premere mj. Per tornare al marcatore dovrete digitare 'j.

I marcatori multipli sono molto utili per andare avanti e indietro dentro un pezzo di codice. Prendendo lo stesso esempio, si può passare dal marcatore su x++; ed un altro a y=x; e poi saltare dall'uno all'altro o a un qualsiasi altro punto e poi tornare indietro.

I marcatori possono estendersi anche a file differenti. Per usare questi marcatori c'è bisogno di usare i registri maiuscoli, A-Z. I registri minuscoli vengono usati solo all'interno di un singolo file e non attraversano file multipli. Per essere chiari, se volete mettere un marcatore in un file foo.c nel registro "a" e poi passate ad un altro file e premete 'a: il cursore non salterà alla posizione precedente. Se volete un marcatore che vi porti ad un file differente avrete bisogno di usare un registro maiuscolo. Ad esempio usate mA invece di ma. Parlerò del lavoro su file multipli in una sezione seguente.

3.3. combinazione gd

Considerate il seguente pezzo di codice

Per qualche ragione avete dimenticato cosa sono y e z e volete tornare alla loro dichiarazione alla svelta. Un modo di farlo sarebbe cercare all'indietro delle y o delle z. VIM offre una soluzione più veloce e semplice. Le lettere gd stanno per Goto Declaration ["vai alla dichiarazione" NdT]. Con il cursore su "y", se premete gd questo si sposterà alla dichiarazione : struct Y y;.

Una combinazione simile è gD: questa vi porta alla dichiarazione globale della variabile sotto il cursore. Dunque se volete andare alla dichiarazione di x, tutto quello che dovete fare è premere gD ed il cursore si sposterà alla dichiarazione di x.

5.1. Restringere l'ampiezza delle colonne

Spesso si deve restringere la larghezza delle colonne a 80 o 75 o qualcos'altro. Ciò può essere fatto facilmente usando il comando

	    :set textwidth=80
	 

Per farlo in maniera automatica semplicemente mettete il comando nel vostro .vimrc.

Oltre alla larghezza delle colonne, potreste desiderare che il testo vada a capo in una determinata colonna. Spesso queste scelte sono dettate dal terminale che si sta usando. In caso la scelta sia libera, il comando è

	    :set wrapwidth=60
	 

Il comando precedente fa immettere testo solo in 60 colonne.

5.2. Indentare automaticamente il codice

Mentre si sta scrivendo codice C, spesso si ha bisogno di indentare dei blocchi interni di codice. Per far questo automaticamente mentre si sta scrivendo il codice, VIM ha un'opzione detta cindent. Per attivarla usate semplicemente il comando

	    :set cindent
	 

Impostando cindent, il codice viene abbellito automaticamente. Per impostare il comando in automatico, aggiungetelo al vostro .vimrc

5.3. Commenti

VIM vi permette anche di auto-formattare i commenti. Potete dividere i commenti in 3 stadi: La prima parte, la parte media e la parte finale. Ad esempio il vostro stile di scrittura del codice potrebbe richiedere dei commenti nella forma seguente

	    /*
	    * Questo è il commento
	    */
	 

In un caso simile potrebbe essere usato il comando seguente

	    :set comments=sl:/*,mb:*,elx:*/
	 

Lasciate che decifri per voi il comando. Il comando ha tre parti. La prima parte é sl:/*. Questa dice a VIM che i commenti in tre pezzi cominciano con /*. La seguente dice a VIM che la parte di mezzo del commento è *. Infine l'ultima sezione del comando dice a vim un bel po' di cose: che il comando dovrebbe finire con */ e che dovrebbe completare il commento in automatico quando premete semplicemente /.

Lasciate che vi dia un altro esempio. Diciamo che il vostro metodo sia il seguente

	    /*
	    ** questo è il commento
	    */
	 

In una situazione simile potreste usare il comando seguente per i commenti

	    :set comments=sl:/*,mb:**,elx:*
	 

Per inserire un commento premete semplicemente /* e invio. La riga seguente conterrà automaticamente il **. Dopo aver finito il commento premete ancora invio e verrà inserito un altro **. Comunque per terminarlo dovrete usare */ e non **/. VIM è abbastanza intelligente in questo. Non avete bisogno di cancellare l'ultimo * e di rimpiazzarlo con /. Invece premete solo / e VIM lo riconoscerà come la fine del commento e cambierà automaticamente la riga da ** a */.

Per ulteriori informazioni premete :h comments