
C editing with VIM HOWTO Siddharth Heroor

   Diario delle revisioni
   Revisione v1.0 Gen 14, 2001 Corretto da: sh
   Seconda Revisione. Corretti alcuni refusi.
   Revisione v0.1 Dic 04, 2000 Corretto da: sh
   Prima Revisione. Mi piacerebbe sapere le vostre reazioni

   Questo documento fornisce un'introduzione alla creazione di file di
   codice in C ed in altri linguaggi la cui sintassi  simile, come il
   C++ e Java, in vi/VIM. Traduzione a cura di Gabriele Renzi
   nickel_it@TOGLIMI.yahoo.it.
     _________________________________________________________________

   Sommario
   1. Introduzione
   2. Spostarsi

        2.1. I tasti "w", "e" e "b"
        2.2. I tasti {, }, [[ e ]]
        2.3. Tasto %

   3. Saltare a posizioni casuali nei file C

        3.1. ctags
        3.2. Marcatori
        3.3. combinazione gd

   4. Auto-Completamento delle parole
   5. Formattare automaticamente

        5.1. Restringere l'ampiezza delle colonne
        5.2. Indentare automaticamente il codice
        5.3. Commenti

   6. Modifica di file Multipli
   7. Quickfix
   8. Copyright
   9. Riferimenti

1. Introduzione

Lo scopo di questo documento  introdurre l'utente principiante di VIM alle
opzioni di editing di VIM per i file C. Il documento introduce alcuni
comandi e combinazioni di tasti che aiuteranno ad essere pi produttivo chi
usa VIM per lavorare su file C.

Lo scopo del documento  mostrare come si possano produrre file C con VIM.
Ad ogni modo la maggior parte di ci che viene descritto qui  applicabile
anche a vi ed al C++, a Java e ad altri linguaggi simili.
     _________________________________________________________________

2. Spostarsi

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

   Figura 1. Un ritaglio di C 

   [moving1.png]
                  ...
                  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

   Figura 2. Un altro ritaglio di C 

   [moving2.png]

   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

   Figura 3. Un altro ritaglio di C 

   [moving3.png]

   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

   Figura 4. Il prossimo ritaglio di codice C 

   [moving4.png]

   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

   Figura 5. Il seguente ritaglio di codice C 

   [moving5.png]

   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. Saltare a posizioni casuali nei file C

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.

   Figura 6. Esempio di tag 

   [tags.png]

   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:

   Figura 7. L'esempio dei marcatori 

   [marks.png]

   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

   Figura 8. Il terzo esempio 

   [gd.png]

   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.
     _________________________________________________________________

4. Auto-Completamento delle parole

Considerate il codice seguente

   Figura 9. Esempio di auto-completamento 

   [auto.png]

   La funzione A_Very_Long_Function_Name() pu essere abbastanza
   esasperante se digitata molte volte. Mentre siete ancora in modalit
   inserimento, potete autocompletare le parole cercando all'indietro o
   in avanti. Nella funzione Another_Function() si pu digitare A_Very...
   e premere CTRL-P. La prima parola simile che viene trovata verr
   mostrata. In questo caso sar A_Very_Long_Variable_Name. Per
   completarla correttamente, si preme CTRL-P ancora e la ricerca
   continua fino alla parola seguente, che  A_Very_Long_Function_Name.
   Appena la parola corretta viene trovata potrete continuare a scrivere.
   VIM rimane in modalit inserimento durante l'intero processo.

   Simile alla combinazione CTRL-P  quella CTRL-N. Questa effettua una
   ricerca in avanti invece che all'indietro. Entrambe le combinazioni
   continuano la ricerca finch arrivano alla fine o all'inizio.

   Sia CTRL-P che CTRL-N sono parte di una modalit conosciuta come
   modalit CTRL-X. La modalit CTRL-X  una sotto-modalit di quella
   inserimento. Dunque potete entrare in questa modalit mentre vi
   trovate in inserimento. Per lasciare CTRL-X basta premere una
   qualsiasi chiave differente da CTRL-X, CTRL-P e CTRL-N. Una volta
   lasciata la modalit CTRL-X ritornerete in modalit inserimento.

   La modalit CTRL-X vi permette di effettuare l'autocompletamento in
   molti modi differenti. Con uno potete perfino autocompletare i nomi di
   file. Questo  particolarmente utile quando dovete includere dei file
   header. Usando la modalit CTRL-X potete includere un file foo.h
   usando il seguente meccanismo.
         #include "f CTRL-X CTRL-F"


   Questo  CTRL-X CTRL-F. Lo so... lo so... sembra emacs ;-). Ci sono
   altre cose che potete fare in modalit CTRL-X. Una di queste  il
   completamento da dizionario. Il completamento da dizionario vi
   permette di specificare un file contenente una lista di parole che
   verranno usate per il completamento. L'opzione dizionario non  attiva
   in maniera predefinita. Questa opzione viene attivata dal comando :set
   dictionary=file. In genere si possono inserire nel dizionario parole
   chiave del C, typedef e #define. I programmatori C++ e Java saranno
   interessati anche ad aggiungere nomi di classi.

   Il formato del file dizionario  semplice. Basta mettete ogni parola
   su una riga a s. Dunque un file dizionario per il C apparir simile a
   questo.

   Figura 10. Un file dizionario d'esempio 

   [dict.png]

   Per usare il completamento da dizionario avete bisogno di premere
   CTRL-X CTRL-K. Il completamento  simile a quello delle combinazioni
   CTRL-P e CTRL-N. Dunque... per scrivere "typedef" tutto quello che
   dovete fare  t CTRL-X CTRL-K e puf... il nome verr completato.
     _________________________________________________________________

5. Formattare automaticamente

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 
     _________________________________________________________________

6. Modifica di file Multipli

Spesso c' bisogno di modificare pi di un sorgente alla volta. Ad esempio
si porrebbe modificare un file header ed un file .c nello stesso momento.
Per lavorare su pi di un file alla volta, richiamate VIM usando il comando
seguente
         $ vim file1 file2 ...


   Ora potrete modificare il primo file e passare al seguente con il
   comando
         :n


   Potete tornare indietro usando il comando
         :e#


   Potrebbe esservi utile, mentre state scrivendo, vedere entrambi i file
   allo stesso tempo e passare da uno all'altro. In altre parole, sarebbe
   utile che lo schermo fosse spezzato in due per permettervi di vedere
   l'header file in alto ed il file sorgente in basso. VIM ha un comando
   del genere per dividere la finestra. Per usarlo, scrivete
   semplicemente: :split 

   Lo stesso file verr mostrato nelle due finestre. Qualunque comando
   venga invocato, avr effetto solo sulla finestra in uso. Dunque si
   potr modificare un altro file in un altra finestra usando il comando
   :e file2 

   Dopo avere eseguito il comando, vi accorgerete che ci sono due file
   visibili. Una finestra mostra il primo file e l'altra il secondo. Per
   saltare tra i due file deve essere usata la combinazione CTRL-W
   CTRL-W. Per saperne di pi sulla divisione in finestre semplicemente
   guardate l'help.
     _________________________________________________________________

7. Quickfix

Quando si sta lavorando su codice C, spesso si segue un ciclo
scrivi-compila-scrivi . In genere voi scriverete il file C usando le cose
che vi ho detto prima, salverete il file, compilerete il codice e tornerete
al sorgente, visti gli errori, per scrivere ancora. VIM vi aiuta a sveltire
il ciclo usando una modalit detta quickfix. Sostanzialmente, si devono
salvare gli errori del compilatore in un file e poi aprirlo con VIM usando
il comando
         $ vim -q compiler_error_file


   VIM apre il file contenente gli errori automaticamente e posiziona il
   cursore nel punto dove si trova il primo errore.

   C' una scorciatoia per il ciclo. Usando il comando "make", il codice
   verr compilato automaticamente e il cursore andr nella posizione
   dove si trova il primo errore. Per usare il comando make scrivete
         :make


   Sostanzialmente, questo comando richiama "make" in una shell e va al
   primo errore. Comunque, se non state compilando usando make e state
   compilando usando un comando come cc, allora dovete impostare una
   variabile detta makeprg per il comando che volete usare come comando
   make. Ad esempio :set makeprg=cc\ foo.c 

   Dopo aver impostato makeprg, baster, ancora, chiamare il comando make
   e quickfix entrer in gioco.

   Dopo che avrete corretto il primo errore, dovrete andare all'errore
   seguente e correggerlo. Il comando che vedete qui sotto viene usato
   per passare all'errore successivo :cn 

   Per tornare indietro, potete usare il comando :cN 

   Lasciate che vi mostri il tutto con un esempio. Considerate il
   seguente codice

   Figura 11. Quickfile Program Listing 

   [quickfix_prog.png]

   Come potete vedere c' un errore nella riga numero 5. Il file 
   salvato come test.c e makeprg viene impostata usando
         :set makeprg=gcc\ test.c


   Poi viene richiamato il comando make tramite :make . gcc restituisce
   un errore e l'output del comando make  qualcosa del genere

   Figura 12. :make error 

   [make_error.png]

   Alla pressione di INVIO, il cursore si sposta alla riga numero 6.

   Ora, il comando :cn sposter il cursore alla riga numero 4.

   Per tornare all'errore precedente, si pu usare il comando :cN ed il
   cursore ritorner alla riga numero 6.

   Dopo aver corretto l'errore alla riga 5 aggiungendo "return 1;", si
   pu eseguire ancora :make e l'output sar

   Figura 13. No Error 

   [make_no_error.png]

   Questo era solo un piccolo esempio. Potete usare quickfix per
   risolvere i vostri problemi di compilazione, si spera, per ridurre il
   tempo del ciclo modifica-compila-modifica.
     _________________________________________________________________

8. Copyright

Copyright (c) 2000,2001 Siddharth Heroor.

Permission is granted to copy, distribute and/or modify this document under
the terms of the GNU Free Documentation License, Version 1.1 or any later
version published by the Free Software Foundation; with no Invariant
Sections, with no Front-Cover Texts, and with no Back-Cover Texts. A copy of
the license can be found at http://www.gnu.org/copyleft/fdl.html 
     _________________________________________________________________

9. Riferimenti

Potete trovare ulteriori informazioni su VIM e scaricarlo da
http://www.vim.org 
