Questo capitolo descrive l'editor standard di NetBSD, e cioè vi. La prima parte del capitolo introduce le basi dell'uso di questo editor, mentre le sezioni successive ne descrivono alcune caratteristiche avanzate, con particolare riferimento alla versione di vi installata con NetBSD. Chi desidera approfondire l'argomento può fare riferimento alla bibliografia alla fine di questo capitolo e ai link presentati nelle sezioni seguenti.
Non c'è bisogno di presentazioni per l'editor vi: da quando è stato sviluppato da Bill Joy, all'Università della California di Berkeley è diventato l'editor standard di quasi tutte le versioni di Unix, il compagno e l'amico fedele degli amministratori di sistema e dei programmatori nonché la bestia nera di quasi tutti i principianti.
Vale dunque la pena di spendere qualche parola sull'uso di questo editor, anche perché, al termine dell'installazione di NetBSD, è l'unico disponibile sul sistema (fatta eccezione per ed) ed è quindi lo strumento che dovrà essere utilizzato per la configurazione iniziale del sistema stesso. In un secondo tempo, naturalmente, ciascuno è libero di installare l'editor che preferisce e conosce meglio, scegliendo tra la nutrita serie di quelli contenuti nella collezione dei package (vedere il Capitolo 8).
Questa sezione contiene un'introduzione all'uso di vi che dovrebbe essere sufficiente a consentire a un principiante di creare e modificare file di testo. Solo le caratteristiche di base e alcuni dei comandi di uso più comune vengono descritti, senza alcuna pretesa di completezza: per una trattazione più esauriente si rimanda ai documenti descritti ne la Sezione 14.2.2.
I principianti non devono commettere l'errore di giudicare vi a partire da queste poche istruzioni: usato in modo così "minimalista", vi è indubbiamente molto scomodo. Le sue virtù si scoprono quando si imparano tutti (!) i suoi comandi e si incominciano a utilizzare le sue funzioni avanzate; a questo punto vi non è più l'editor ostico degli inizi ma diventa uno strumento comodo, potente e affidabile. Questa guida è stata scritta, inutile dirlo, utilizzando l'editor vi.
Per lanciare vi, dare il comando:
$ vi nomefiledove nomefile è il nome del file da editare (che può anche non esistere ancora). Se nomefile viene omesso, vi parte con un file inizialmente vuoto (e ancora senza nome: sarà necessario dargliene uno al momento di salvarlo). In questo esempio supponiamo di creare un file nuovo:
$ vi miofiledove miofile è il nome di un file che non esiste nella directory corrente.
Una volta avviato vi, lo schermo mostra una colonna di caratteri tilde sulla sinistra e, sull'ultima riga, il nome del file, insieme a alcune informazioni di significato evidente; una cosa di questo tipo (ma con più righe):
~ ~ ~ ~ ~ ~ miofile: new file: line 1I caratteri tilde a inizio linea indicano che la linea in questione è vuota, cioè che la linea non contiene testo. Poiché il file caricato (miofile) non esisteva, tutte le righe sullo schermo di vi sono vuote.
A questo punto la pressione della maggior parte dei tasti provoca un segnale acustico o la visualizzazione di un messaggio d'errore (si provi, per esempio, a premere j oppure k). Ciò è dovuto al fatto che vi è un editor modale e pertanto i tasti premuti hanno un effetto diverso al seconda del "modo" in cui si trova l'editor. All'avvio vi si trova sempre in modo comandi e tutti i tasti premuti vengono interpretati come comandi per l'editor, anziché come testo da inserire nel file; pertanto, premendo j, vi non inserisce una "j" nel file ma cerca di eseguire il comando j che, come si vedrà tra breve, significa "sposta il cursore alla linea seguente". Poiché il file è ancora vuoto, non c'è alcuna linea seguente su cui portare il cursore e viene segnalato un errore.
Alcuni dei comandi di vi consentono di passare dal modo comandi al modo inserimento; una volta entrati in questo modo tutto ciò che si scrive viene interpretato come testo da inserire nel file. Vediamo ora un esempio.
Premere i per passare in modo inserimento e digitare le seguenti linee di testo (terminare ogni riga con Invio):
Prima riga di testo inserito, seconda riga di testo inserito, terza e ultima riga di testo inserito.al termine dell'inserimento premere ESC per tornare in modo comandi.
In questo esempio abbiamo visto come passare dal modo comandi al modo inserimento premendo i, come inserire alcune righe di testo, terminando ciascuna riga con il tasto Invio, e come tornare infine al modo comandi premendo ESC. Adesso che il file contiene un po' di testo si possono sperimentare alcuni comandi; i primi che vedremo sono quelli che consentono di spostarsi all'interno del file.
Nota: il testo inserito appartiene logicamente al file miofile (il nome passato come parametro all'editor) ma, per il momento, risiede solamente nella memoria dell'editor perché non è ancora stato salvato su file. Tutte le operazioni effettuate sul testo (aggiunte, modifiche, ecc.) non vengono salvate su disco finché l'utente non lo richiede esplicitamente con un comando di salvataggio del file. Pertanto è sempre possibile abbandonare le modifiche uscendo dall'editor senza salvare e la copia del file su disco rimarrà invariata. I comandi per salvare/abbandonare/uscire sono descritti ne la Sezione 14.1.9.
Quando ci si trova in modo comandi, alcuni comandi consentono di spostarsi all'interno di un file (cioè di modificare la posizione del cursore). L'elenco seguente riassume i principali comandi di spostamento.
h cursore a sinistra (freccia a sinistra) j cursore in basso (freccia verso il basso) k cursore in alto (freccia verso l'alto) l cursore a destra (freccia a destra) ^F pagina seguente (PgDn) ^B pagina precedente (PgUp) 0 cursore a inizio riga $ cursore a fine riga b parola precedente w parola seguente Invio primo carattere della riga seguente (spazi esclusi) + primo carattere della riga seguente (spazi esclusi) - primo carattere della riga precedente (spazi esclusi)(il simbolo ^ indica la pressione del tasto Control insieme al tasto che rappresenta la lettera che segue; pertanto ^F significa Control-F). A seconda della configurazione del terminale è anche possibile che l'editor riesca a utilizzare i tasti freccia e i tasti PgUp e PgDn.
Si noti che, come già detto, questi tasti servono per spostarsi quando ci si trova in modo comandi: se premuti in modo inserimento, invece, causano l'inserimento del testo relativo all'interno del file (cioè premendo h il carattere 'h' viene inserito nel file). Osserviamo quindi un primo fatto: in modo inserimento si può solo inserire testo sequenzialmente; per potersi spostare all'interno del file occorre uscire dal modo inserimento (con ESC) tornando al modo comandi. Questa è una delle conseguenze del fatto che vi è un editor modale.
In modo comandi è possibile spostarsi nel file anche specificando il numero di riga sulla quale ci si vuole portare. Per esempio:
12G vai alla riga 12Il comando G senza prefisso numerico porta il cursore a fine file.
Prefissi numerici: molti comandi di vi accettano un prefisso numerico che ne modifica l'interpretazione da parte dell'editor. Anche se l'uso del prefisso numerico non viene qui descritto, riportiamo alcuni esempi tanto per dare un'idea dei possibili utilizzi.
9k cursore 9 righe verso l'alto 12dd cancella dodici righe 3w cursore avanti di tre parole 5x cancella 5 caratteri
In questa sezione sono stati descritti alcuni dei principali comandi di spostamento, che possono essere provati sulle linee di testo appena inserite. L'editor vi dispone di molte altre funzioni sofisticate per spostarsi all'interno del file, che però non vengono descritte in questo breve tutorial.
Nell'esempio iniziale si è già visto che per passare da modo inserimento a modo comandi bisogna premere il tasto ESC. Se si è preme ESC mentre vi è già in modo comandi, l'editor emette una innocua segnalazione acustica e, pertanto, se non ci si ricorda qual'è il modo corrente si può sempre premere ESC, con la garanzia di ritrovarsi in modo comandi.
Se ESC è l'unico metodo per tornare al modo comandi, i comandi che permettono di entrare in modo inserimento sono molti. A seconda del comando scelto l'effetto risulta diverso, come si può osservare dalla seguente tabella.
i inserisci testo prima del cursore a inserisci testo dopo il cursore A inserisci testo a fine riga I inserisci testo a inizio riga o apri una riga vuota dopo la riga corrente O apri una riga vuota prima della riga correnteLa presenza di numerosi comandi che fanno cose simili è una costante dell'editor vi; l'effetto è quello di avere molti modi per fare la stessa cosa, e quindi molte possibili soluzioni. L'esperto di vi riesce solitamente a trovare la soluzione che gli consente di portare a termine la funzione desiderata con il minor numero possibile di comandi. Per esempio, per inserire la parola "fine" a fine riga si possono utilizzare queste due sequenze equivalenti:
$afineESC AfineESCnella prima ci si porta a fine riga con il comando $, poi si passa in modo inserimento con a, si aggiunge la stringa "fine" e si ritorna in modo comandi premendo ESC. Nella seconda sequenza, il comando A combina le funzioni di $ e di a in un tasto solo.
La tabella seguente riassume alcuni comandi per la cancellazione di testo.
dd cancella la riga corrente x cancella il carattere sotto al cursore X cancella il carattere prima del cursore dw cancella fino a fine parola D cancella dal cursore a fine rigaanche questi comandi si possono dare in modo comandi, e non in modo inserimento. Da qui in avanti non verrà più indicato il fatto che i comandi operano in modo comandi poiché dovrebbe essere oramai evidente. Quando verranno descritte alcune funzioni attivabili dal modo inserimento, questo fatto verrà indicato esplicitamente.
Vediamo ora un esempio pratico che riassume l'uso di alcuni dei comandi presentati nelle sezioni precedenti. Supponiamo che il file in corso di editazione sia composto dalle tre righe inserite nell'esempio iniziale e che si voglia trasformare la terza riga in questo modo:
terza riga di testo inserito nel file.Come prima operazione cancelliamo dall'ultima riga le parole "e ultima " e poi inseriamo il nuovo testo " inserito nel file" alla fine della riga, prima del punto.
Supponiamo che il cursore si trovi sulla prima riga (se così non fosse, portarsi sulla prima riga con il comando 1G). Per andare dalla prima alla terza riga si può usare una delle sequenze seguenti (ma ve ne sono anche altre):
<Invio><Invio>
jj
3G
/terza/<Invio>
Una volta arrivati all'inizio della terza riga ci si porta sulla prima delle due parole da cancellare con
wInfine si cancellano le due parole con:
dwdw
Nota: ricordando quanto accennato sui prefissi numerici, si può intuire che i due comandi dw appena dati possono essere sostituiti dall'unico comando 2dw, che cancella due parole in un colpo solo, o anche, il che può apparire sorprendente, da d2w.
Per aggiungere il nuovo testo ci si porta a fine riga con il comando $, si entra in modo inserimento con i e poi si scrive:
inserito nel filePremendo ESC si torna in modo comandi.
Per cercare una stringa all'interno del file corrente si usano i seguenti comandi:
/stringa/ ?stringa?il primo comando (seguito da Invio) cerca la stringa nel file andando avanti, cioè verso fine file, a partire dalla posizione del cursore. Il secondo comando (anch'esso seguito da Invio) cerca la stringa andando all'indietro, cioè verso l'inizio del file.
Per esempio, ritornando alle tre linee inserite inizialmente si provi a dare i seguenti comandi:
1G/ultima/e a premere invio. Il comando 1G fa spostare il cursore sulla prima riga del file (si noti che non viene fatta l'eco del comando). La sequenza /ultima/ (che viene visualizzata sull'ultima riga dello schermo) seguita da Invio causa la ricerca della stringa "ultima" all'interno del testo e lo spostamento del cursore sulla riga relativa.
Nota: i comandi di ricerca costituiscono quindi un ulteriore metodo di spostamento all'interno del file, mirato al contenuto del file stesso.
Per ripetere l'ultima ricerca effettuata senza doverla riscrivere si possono usare i comandi
n ripeti la ricerca nella stessa direzione N ripeti la ricerca nella direzione opposta
Anche quando si sta inserendo del testo sono disponibili alcuni comandi, generalmente ottenuti con il tasto Control:
^H cancella il carattere a sinistra del cursore BS cancella il carattere a sinistra del cursore ^W cancella la parola precedente ^U cancella fino a inizio riga ESC torna in modo comandi
Se, una volta tornati in modo comandi, ci si accorge di aver commesso un errore è possibile utilizzare il comando di undo (il tasto u) per annullare l'ultimo comando eseguito.
I principali comandi per terminare il lavoro e uscire da vi oppure semplicemente per salvare e continuare a lavorare sono:
:w salva il file (senza uscire) :q esci :wq salva il file e esci :q! esci senza salvare (le modifiche vanno perse) :w abc salva il file dandogli il nome 'abc'Per cambiare il nome al file corrente (o per dargliene uno se non ce l'ha):
:file nomefile
I comandi descritti in questa sezione sono esempi di un'ulteriore modalità di funzionamento di vi, il modo ex, che in questa breve introduzione non viene descritto. L'editor vi nasce infatti dalla combinazione di due distinti editor dei quali uno (vi, per l'appunto) serve da interfaccia full screen per l'altro (ex), che fornisce le funzioni base per l'editing. Ex si può ritenere una versione evoluta dell'editor ed.
Come già accennato nell'introduzione, in questa sezione sono stati descritti solo i comandi più elementari dell'editor vi, per consentire l'editing dei file di configurazione di NetBSD al termine dell'installazione. Per poter usare questo editor in modo produttivo (e comodo) è necessario approfondire la conoscenza dei comandi leggendo, per esempio, i documenti citati ne la Sezione 14.2.2.
L'editor standard in dotazione a NetBSD è, come già detto, vi. Se non utilizzate vi questa sezione non vi interessa, in caso contrario leggetela prima di correre a installare vim o elvis. Il vi di NetBSD è, infatti, nvi, una versione storica di vi con molte potenti estensioni scritta da Keith Bostic dell'Università della California di Berkeley verso i primi anni 90 per avere una versione liberamente ridistribuibile di vi e diventata in seguito la versione ufficiale di BSD.
Tra le estensioni più interessanti troviamo
Espressioni regolari estese (abilitate con l'opzione extended).
Tag stacks.
Undo infinito (attivato in modo un po' curioso: per il primo undo si preme u; gli undo successivi si ottengono premendo il carattere punto (.)).
Ricerca incrementale (abilitata con l'opzione searchincr).
Scrolling delle linee (abilitato dall'opzione leftright; il numero delle colonne è definito da sidescroll).
History della linea di comando (controllata dall'opzione cedit).
Completamento della linea di comando (controllata dall'opzione filec).
Schermi che si possono mettere in foreground e in background.
Split screen.
Nell'esempio seguente vediamo qualche comando di configurazione che ci semplifica un po' la vita.
set showmode ruler set filec=^[ set cedit=^[
La prima riga abilita la visualizzazione della posizione del cursore (riga e colonna) e della modalità corrente (Command, Insert, Append) sulla riga di stato. La seconda riga (^[ è il carattere ESC) abilita il completamento dei nomi dei file e la terza la history della linea di comando: entrambe utilizzeranno il carattere ESC. Per esempio, scrivendo ':' e poi premendo ESC si apre una finestra con l'elenco dei precedenti comandi; l'elenco si può modificare come se fosse un file. Quando si preme invio su una riga il corrispondente comando viene eseguito.
Nel tarball dei sorgenti (src.tgz) è contenuta una notevole quantità di documentazione originale di vi/nvi: si trova in /usr/src/usr.bin/vi/docs. In particolare si possono trovare:
Edit: A tutorial
Ex Reference Manual
Pagina di manuale di vi
An Introduction to Display Editing with Vi di William Joy e Mark Horton
Ex/Vi Reference Manual di Keith Bostic, il manuale di riferimento di nvi, che descrive in dettaglio tutti i comandi dell'editor.
Vi Command & Function Reference
Vi tutorial (beginnner e advanced)
Chi desidera imparare a usare vi deve iniziare a leggere An Introduction to Display Editing with Vi di William Joy e Mark Horton, per poi passare a Ex/Vi Reference Manual di Keith Bostic.
Questo argomento non è strettamente legato a NetBSD ma, già che ci siamo, merita un piccolo approfondimento perché può essere comodo per esaminare, per esempio, i sorgenti del kernel o di un programma complesso, composto da più subdirectory.
I tag sono una di quelle caratteristiche che rendono vi un potente strumento di editing per programmatori: si tratta in sostanza di un file contenente un elenco di nomi di procedure, macro, ecc. presenti nei sorgenti di un programma. Quando si editano i sorgenti, grazie ai tag è possibile saltare dal punto in cui viene chiamata una funzione al punto in cui è definita la funzione stessa. Per esempio, supponiamo di esaminare un sorgente con le seguenti righe:
for (i = 0; i < len; i++) funcXY(i);portandosi con il cursore sulla prima lettera di "funcXY" e premendo ^] (Control- [), vi automaticamente apre il sorgente in cui è presente la definizione di funcXY e si posiziona sulla funzione stessa.
void
funcXY(i)
int i;
{
funcZ();
...
Una volta esaminata/modificata funcXY, premendo
^T (Control-T) si ritorna al file e alla
posizione iniziale (quella del ciclo for).
Si noti che questi "salti" possono essere annidati;
se con ^] si salta alla funzione funcXY, e poi
con un successivo ^] si salta alla funzione
funcZ, con due ^T si ritorna al file e alla
posizione iniziale.Per ottenere il risultato descritto nel paragrafo precedente è necessario che vi trovi un file (solitamente) chiamato tags nella directory corrente o in una posizione da noi specificata con il comando :set tags=/percorso/nomefile (questo comando si può anche inserire nel file .exrc). Tale file, che poi è un file di testo, viene generato dal programma ctags. Per esempio il comando:
$ ctags *.c *.hgenera il file tags nella directory corrente. Quando parte vi, il file ./tags viene trovato automaticamente.
Quando si esaminano dei sorgenti che si trovano in una gerarchia di directory e sottodirectory si possono ugualmente generare e utilizzare i tag di vi. La procedura è la seguente.
Ci si porta nella directory base dei sorgenti, con il comando
$ cd /percorso
Si costruisce il file dei tag in due passaggi; prima si crea una lista dei file sorgenti da eseminare e poi la si sottomette al programma ctags per creare il file tags.
$ find . -name "*.[ch]" > filelist
$ ctags -L filelist
In ./.exrc si inserisce la linea
set tags=/percorso/tagssostituendo il percorso appropriato al posto di "percorso".
Nvi è la versione di vi nativa di NetBSD, ma non è certamente l'unica esistente. Senz'altro è una delle più vicine allo spirito della versione originale del programma, e quindi, se siete dei puristi, non vorrete usare altro, come del resto fanno molti degli stessi sviluppatori di NetBSD. Tuttavia esistono molti "cloni" di questo programma, alcuni dei quali molto diffusi e apprezzati, e pertanto chi si trova bene a lavorare con vi ma cerca "qualcosa in più" ha un'ampia rosa di scelte. Per una panoramica completa i siti "The VI pages" (http://www.math.fu-berlin.de/~guckes/vi) e "Vi Lovers Home Page" (http://www.thomer.com/thomer/vi/vi.html) sono il miglior punto di partenza. Oltre alla descrizione e ai link per tutti i cloni esistenti di vi, vi sono collegamenti a tutorial e informazioni varie.
Per iniziare a districarsi nella giungla dei programmi consiglio di dare un'occhiata a vim e vile. Si tratta di due versioni "potenziate" di vi, a cui sono stati aggiunti molti comandi, supporto per il mouse (nelle versioni X), evidenziazione della sintassi dei file sorgenti con colori diversi, possibilità di spostarsi all'interno di un file anche quando si è in modalità inserimento e tante, tante altre funzionalità. La filosofia dei due programmi, ottimi entrambi e meritevoli di essere provati, è molto diversa. Vile, in particolare, è programmabile, essendo dotato di un vero macrolinguaggio che consente di definire procedure e assegnarle ai tasti e quindi piacerà agli amanti della personalizzazione estrema. Vim, dal canto suo, è forse il clone più diffuso e amato, dotato di un ricchissimo (anche troppo) assortimento di nuovi comandi, molti dei quali studiati per i programmatori.