USR_30

*usr_30.txt*	Per Vim version 6.2.  Ultima modifica: 2004 Gen 17

		     VIM USER MANUAL - di Bram Moolenaar
	       Traduzione di questo capitolo: Alessandro Melillo

			      Editare programmi


Vim ha diversi comandi che sono d'aiuto nello scrivere programmi per computer.
Compila un programma e salta direttamente agli errori riscontrati.  Definisce
automaticamente l'indentazione per molti linguaggi e formatta i commenti.

|30.1|	Compilazione
|30.2|	Indentazione dei files in C
|30.3|	Indentazione automatica
|30.4|	Altre indentazioni
|30.5|	Tabulazioni e spazi
|30.6|	Formattazione dei commenti

  Capitolo seguente: |usr_31|  Sfruttare la GUI
Capitolo precedente: |usr_29|  Spostarsi attraverso i programmi
	     Indice: |usr_toc|

*30.1*	Compilazione

Vim ha una serie di comandi cosiddetti "quickfix".  Questi permettono di
compilare un programma all'interno di Vim e successivamente esaminare gli
errori generati e correggerli (fortunatamente).  Poi è possibile ricompilare e
correggere ogni altro errore si trovasse, sino a che il nostro programma non
compili senza errori.

Il comando seguente lancia "make" (con qualsiasi argomento gli si passi) e
cattura il risultato:

	:make {arguments}

Se vengono generati errori, vengono catturati e l'editor vi posiziona nel
punto in cui si è verificato il primo errore.
   Date un'occhiata a una sessione ":make" d'esempio. (le sessioni :make
tipiche generano molti errori ed assai meno di quelli stupidi).  Dopo aver
scritto ":make" lo schermo appare così:

	:!make | &tee /tmp/vim215953.err 
	gcc -g -Wall -o prog main.c sub.c 
	main.c: In function 'main': 
	main.c:6: too many arguments to function 'do_sub' 
	main.c: At top level: 
	main.c:10: parse error before '}' 
	make: *** [prog] Error 1 

	2 returned 
	"main.c" 11L, 111C 
	(3 of 6): too many arguments to function 'do_sub' 
	Hit ENTER or type command to continue 

Da qui potete vedere che ci sono errori nel file "main.c".  Premendo <Enter>,
Vim mostra il file "main.c", con il cursore posizionato alla linea 6, la prima
contenente un errore.  Non avete avuto bisogno di specificare il file od il
numero di riga, Vim sapeva dove andare per guardare i messaggi d'errore.

		+---------------------------------------------------+
		|int main()					    |
		|{						    |
		|	int i=3;				    |
      cursor -> |	do_sub("foo");				    |
		|	++i;					    |
		|	return (0);				    |
		|}						    |
		|}						    |
		| ~						    |
		|(3 of 12): too many arguments to function 'do_sub' |
		+---------------------------------------------------+

Il comando seguente va dove si trova il prossimo errore:

	:cnext

Vim salta alla linea 10, l'ultima del file, dove c'è una '}' di troppo.
   Quando non c'è sufficiente spazio, Vim abbrevia il messaggio d'errore.  Per
vedere il messaggio intero usate:

	:cc

Potete ottenere un sommario di tutti gli errori con il comando ":clist".
L'output appare così:

	:clist
	3 main.c: 6:too many arguments to function 'do_sub' 
	5 main.c: 10:parse error before '}' 

Solo le righe in cui Vim riconosce un nome di file ed un numero di linea
vengono elencate.  Assume che quelle siano le linee interessanti e che il
resto sia costituito solo da messaggi noiosi.  Comunque, a volte linee non
riconosciute contengono qualcosa che volete vedere.  Per esempio, l'output del
linker riguardo una funzione non definita.
   Per vedere tutti i messaggi aggiungete un "!" al comando:

	:clist!
	1 gcc -g -Wall -o prog main.c sub.c 
	2 main.c: In function 'main': 
	3 main.c:6: too many arguments to function 'do_sub' 
	4 main.c: At top level: 
	5 main.c:10: parse error before '}' 
	6 make: *** [prog] Error 1 

Vim evidenzierà l'errore corrente.  Per tornare al precedente, usate:

	:cprevious

Altri comandi per spostarvi nella lista errori:

	:cfirst		al primo errore
	:clast		all'ultimo errore
	:cc 3		all'errore numero 3


USARE UN ALTRO COMPILATORE

Il nome del programma da eseguire quando si impartisce il comando ":make" è
definito dall'opzione 'makeprg'.  Solitamente è settata a "make", ma gli
utenti di Visual C++ dovrebbero settarlo a "nmake" eseguendo il seguente
comando:

	:set makeprg=nmake

Potete anche includere argomenti in questa opzione.  Caratteri speciali devono
essere protetti con un backslash.  Esempio:

	:set makeprg=nmake\ -f\ project.mak

Potete includere parole chiave speciali di Vim nella specifica del comando.
Il carattere % si espande al nome del file corrente.  Così, se eseguite il
comando:

	:set makeprg=make\ %

Mentre editate main.c, allora ":make" esegue il seguente comando:

	make main.c

Questo non è troppo utile, quindi potete ridefinire un po' il comando ed usare
il modificatore :r (root):

	:set makeprg=make\ %:r.o

Ora il comando eseguito è questo:

	make main.o

Maggiori informazioni sui modificatori si trovano qui: |filename-modifiers|.


VECCHIE LISTE D'ERRORE


Supponiamo di eseguire ":make" su un programma.  C'è un messaggio di avviso
in un file e uno di errore in un altro.  Correggete l'errore ed usate ancora
":make" per controllare se sia stato realmente corretto.  Adesso volete
guardare il messaggio di avvertimento.  Non compare nell'ultima lista di
errori, poichè il file con l'avviso non è stato ricompilato.  Si può tornare
alla lista precedente con:

	:colder

E poi usare ":clist" e ":cc" {nr} per saltare al punto con l'avviso.
   Per andare avanti alla successiva lista di errori:

	:cnewer

Vim ricorda dieci liste d'errori.


ALTERNARE I COMPILATORI

Bisogna dire a Vim in quale formato il nostro compilatore produca i messaggi
d'errore.  Ciò viene fatto con l'opzione 'errorformat'.  La sintassi di questa
opzione è piuttosto complicata e si può adattare a qualsiasi compilatore.
Potete trovare la spiegazione è qui: |errorformat|.

Potreste usare diversi compilatori.  Settare l'opzione 'makeprg', e
specialmente 'errorformat' ogni volta non è semplice.  Vim offre un metodo
semplice per farlo.  Per esempio, per passare ad usare il compilatore
Microsoft Visual C++:

	:compiler msvc

Questo comando troverà lo script di Vim per il compilatore "msvc" ed imposterà
le opzioni appropriate.
   Potete anche scrivere i vostri file di opzioni. Vedere
|write-compiler-plugin|.

REINDIRIZZAMENTO DELL'OUTPUT

Il comando ":make" redirige l'output del programma eseguito ad un file
d'errore.  Come ciò funzioni dipende da diversi fattori quali la 'shell'.  Se
il vostro comando ":make" non cattura l'output verificate le pozioni 'makeef'
e 'shellpipe'.  Anche le opzioni 'shellquote' e 'shellxquote' potrebbero
essere utili.

Nel caso in cui non riusciate ad ottenere che ":make" rediriga l'output per
voi, un'alternativa è compilare il programma in un'altra finestra e
reindirizzare l'output in un file.  Quindi farlo leggere a Vim con:

	:cfile {nomefile}

Saltando agli errori funzionerà come con il comando ":make".

*30.2*	Indentazione dei files in C

Un programma è molto più facile da capire quando le linee siano state
indentate appropriatamente.  Vim offre numerosi modi per farlo con meno
lavoro.
   Per i programmi in C occorre settare l'opzione 'cindent'.  Vim sa molto
dei programmi in C e cercherà in ogni modo di impostare l'indentazione per
voi.  Impostate l'opzione 'shiftwidth' al numero di spazi che volete per un
livello più profondo.  Quattro spazi vanno bene.  Basta un solo comando
":set":

	:set cindent shiftwidth=4

Con questa opzione abilitata, quanto scrivete qualcosa tipo "if (x)", la
linea successiva verrà automaticamente indentata ad un livello aggiuntivo.


				    if (flag)
	Indent automatico  --->		do_the_work();
	Unindent automatico <--	    if (other_flag) {
	Indent automatico  --->		do_file();
	Mantenimento  indent		do_some_more();
	Unindent automatico <--	    }

Quando scrivete qualcosa tra parentesi graffe ({}), il testo verrà indentato
all'inizio ma non alla fine.  L'unindent verrà fatto dopo aver battuto
'}', poichè Vim non può indovinare cosa state per scrivere.

Un effetto collaterale dell'indentazione automatica è che vi aiuta a trovare
rapidamente gli errori nel codice.  Quando battete una } per concludere una
funzione, il solo vedere che l'indentazione automatica non si collochi dove
previsto vi aiuta a capire che manca una }.  Usate il comando "%" per trovare
quale { corrisponda alla } che avete appena battuto.
   Anche una ) o un ; mancanti causano un ulteriore indent.  Così, se vedete
più spazio bianco di quello che vi aspettavate, controllate le linee
precedenti.

Quando avete del codice che sia mal formattato. od avete inserito e cancellato
delle linee, dovrete reindentarlo. l'operatore "=" lo fa.  La forma più
semplice è:

Questo indenta la linea corrente.  Come con tutti gli operatori, ci sono tre
modi per usarlo.  In Visual_Mode "=" indenta le linee selezionate.  Un
utile oggetto testuale è "a{".  Questo seleziona il blocco {} corrente.  Così,
per reindentare il blocco di codice in cui si trova il cursore:

	=a{

Se avete del codice veramente mal indentato, potete reindentare l'intero file
con:
	gg=G

Comunque, non fatelo con dei file che avete indentato con cura
manualmente.  L'indentazione automatica fa un buon lavoro, ma in certe
situazioni potreste volerla evitare.


IMPOSTARE LO STILE DI INDENTAZIONE

Persone diverse hanno differenti stili di indentazione.  Per default, Vim fa
un gradevole buon lavoro di indentazione, nel modo in cui lo fa il 90% dei
programmatori.  Comunque ci sono diversi stili; quindi, se volete, potete
personalizzare lo stile di indentazione con l'opzione 'cinoptions'.
   Per default 'cinoptions' è vuota e Vim impiega il proprio stile
predefinito.  Potete aggiungere istanze quando volete qualcosa di diverso. Per
esempio, per far sì che le parentesi graffe vengano posizionate così:

	if (flag) 
	  { 
	    i = 8; 
	    j = 0; 
	  } 

Usate questo comando:

	:set cinoptions+={2

Ci sono molti oggetti del genere. Vedere |cinoptions-values|.

*30.3*	Indentazione automatica

Non volete attivare l'opzione 'cindent' manualmente ogni volta che
editate un file in C.  Ecco come farlo avvenire in automatico:

	:filetype indent on

In realtà, questo fa molto di più che attivare 'cindent' per i sorgenti C.
Prima di tutto, abilita l'individuazione del tipo di file.  La stessa usata
per l'evidenziazione della sintassi.
   Una volta conosciuto il tipo di file, Vim cercherà un tipo di indentazione
per questo tipo di file.  La distribuzione di Vim include un buon numero di
questi tipi per vari linguaggi di programmazione.  Il file di indentazione poi
si preoccuperà di predisporre la giusta indentazione per il file corrente.

Se non vi piace l'indentazione automatica, potete disattivarla:

	:filetype indent off

Se non vi piace l'indentazione per un determinato tipo di file, ecco come
evitarla.  Create un file con questa linea:

	:let b:did_indent = 1

Adesso dovete salvarlo con un nome specifico:

	{directory}/indent/{filetype}.vim

Dove {filetype} è il nome del tipo di file, come "cpp" o "java".  Potete
vedere l'esatto nome che Vim ha rilevato con questo comando:

	:set filetype

In questo file l'output è:

	filetype=help 

E quindi dovreste usare "help" come {filetype}.
   Per la parte {directory} dovete utilizzare la vostra directory di runtime.
Guardate l'output di questo comando:

	set runtimepath

Adesso utilizzate il primo elemento, il nome che precede la prima virgola.
Quindi, se l'output appare così:

	runtimepath=~/.vim,/usr/local/share/vim/vim60/runtime,~/.vim/after 

Usate "~/.vim" come {directory}. Quindi il nome di file risultante è:

	~/.vim/indent/help.vim 

Invece di disattivare l'indentazione, potreste scrivere un vostro indent
file.  Come farlo è spiegato qui: |indent-expression|.

*30.4*	Altre indentazioni

La forma più semplice di indentazione automatica è quella dell'opzione
'autoindent'.  Usa l'indentazione della riga precedente. Un po' più furba è
l'opzione 'smartindent'.  E' utile per i file che non hanno un indent file.
'smartindent' non è intelligente come 'cindent' ma lo è sempre più di
'autoindent'.
   Con 'smartindent' impostata viene aggiunto un livello extra di indentazione
dopo ogni { e tolto un livello dopo ogni }.  Viene aggiunto un livello extra
anche per ognuna delle parole contenute nell'opzione 'cinwords'.  Le righe che
iniziano con # vengono trattate in maniera speciale: viene tolta tutta
l'indentazione.  Viene fatto perchè le direttive di preprocessore così
inizieranno tutte alla colonna 1.  L'indentazione viene ripristinata alla
linea successiva.


CORREZIONE DELLE INDENTAZIONI

Quando state usando 'autoindent' o 'smartindent' per ottenere l'indentazione
della prima linea, molte volte dovrete aggiungere o rimuovere un valore di
'shiftwidth' dell'indentazione.  Un modo rapido per farlo è usare i comandi
CTRL-D e CTRL-T nell'Insert mode.
   Ad esempio, state scrivendo uno script di shell che si suppone appaia come
questo:

	if test -n a; then 
	   echo a 
	   echo "-------" 
	fi 

Iniziate impostando questa opzione:

	:set autoindent shiftwidth=3

Iniziate scrivendo la prima linea,  <Enter> e l'inizio della seconda:

	if test -n a; then 
	echo 

Ora vi accorgete di aver bisogno di un'indentazione in più.  Scrivete CTRL-T.
Il risultato:

	if test -n a; then 
	   echo 

Il comando CTRL-T, nell'Insert mode, aggiunge un solo valore di 'shiftwidth'
all'indentatura, nulla in quella ove vi trovate.
   Continuate a scrivere la seconda linea, <Enter> e la terza linea.  Questa
volta l'indentazione è OK.  Allora <Enter> e la prossima linea.  Adesso avrete
questo:

	if test -n a; then 
	   echo a 
	   echo "-------" 
	   fi 

Per rimuovere l'indentatura superflua nell'ultima linea premete CTRL-D.  Ciò
cancellerà un solo valore di 'shiftwidth', non ha importanza dove vi troviate
nella linea.
   Quando siete in Normal mode, potete usare i comandi ">>" e "<<" per
cambiare linea.  ">" e "<" sono operatori, così avete i soliti tre modi per
specificare le linee che volete indentare.  Una combinazione utile è:

	>i{

Ciò aggiungerà un'indentatura all'attuale blocco di linee, entro {}.  Le
linee comprese tra { e } verranno lasciate non modificate.  ">a{" le
include.  In questo esempio il cursore è su "printf":

	original text		after ">i{"		after ">a{"

	if (flag)		if (flag)		if (flag) 
	{			{			    { 
	printf("yes");		    printf("yes");	    printf("yes"); 
	flag = 0;		    flag = 0;		    flag = 0;  
	}			}			    } 

*30.5*	Tabulazioni e spazi

'tabstop' è impostato ad otto di default.  Sebbene lo possiate cambiare,
facilmente vi ritroverete nei problemi dopo.  Altri programmi potrebbero non
sapere quale valore di tabstop abbiate usato.  Essi probabilmente usano il
valore di default di otto spazi ed il vostro testo sembrerà improvvisamente
assai diverso.  Parimenti molte stampanti usano un valore fisso di tabstop di
otto spazi.  Così è meglio lasciar perdere 'tabstop'.  (Se state lavorando con
un file che sia stato scritto con una diversa impostazione di tabstop, vedete
|25.3| per correggere ciò).
   Indentare le linee di un programma usando un multiplo di otto spazi vi farà
rapidamente andare verso il bordo destro della finestra.  Usare uno spazio
solo non fornirà abbastanza differenza alla vista.  Molti preferiscono usare
quattro spazi, un buon compromesso.
   Sino a quando un <Tab> è di otto spazi e voi invece volete indentare di
quattro, non potete usare un carattere di <Tab> per fare la vostra
indentazione.  Ci sono due modi per gestire la cosa:

1.  Usare un mix di <Tab> e di spazi.  Poichè un <Tab> prende il posto di otto
    spazi, nel vostro file ci staranno meno caratteri.  Inserire un <Tab> è
    più rapido che inserire otto spazi.  Il backspace lavora più velocemente e
    bene.

2.  Usare solo degli spazi.  Evita fastidi con programmi che usano un valore
    diverso di tabstop.

Fortunatamente, Vim supporta entrambi i metodi altrettanto bene.


SPAZI E TABULATORI

Usando una combinazione di tabulatori e di spazi lavorate correttamente.
I default di Vim consentono di utilizzare agevolmente ciò.
   Potete far vita migliore impostando l'opzione 'softtabstop'.
Questa opzione dice a Vim di far sembrare che il tasto <Tab> sia stato
impostato al valore di 'softtabstop', mentre si sta usando una combinazione di
spazi e tabulazioni.
   Dopo aver eseguito il comando che segue, ogni volta che premerete il tasto
<Tab> il cursore si sposterà al limite delle prossime quattro colonne:

	:set softtabstop=4

Iniziando dalla prima colonna e premendo <Tab>, avrete quattro spazi inseriti
nel vostro testo.  La seconda volta Vim assumerà i quattro spazi e li porrà
entro un <Tab> (portandovi così all'ottava colonna).  Così Vim usa il massimo
numero di <Tab> che sia possibile e riempie il resto con degli spazi.
   Usando il backspace opera più o meno in altra maniera.  Un <BS> cancellerà
sempre il numero di spazi previsto da 'softtabstop'.  Così si adoperano il più
possibile i <Tabs> e gli spazi per riempire i vuoti.
   Quanto segue mostra cosa accada premendo <Tab> alcune volte, e poi usando
<BS>.  Un "." sta per uno spazio e  "------->" per un <Tab>.

	type			  result 
	<Tab>			  ....
	<Tab><Tab>		  ------->
	<Tab><Tab><Tab>		  ------->....
	<Tab><Tab><Tab><BS>	  ------->
	<Tab><Tab><Tab><BS><BS>   ....

Un'alternativa consiste nell'usare l'opzione 'smarttab'.  Quando questa viene
impostata, Vim usa 'shiftwidth' ad ogni <Tab> usato per indentare una linea ed
un vero <Tab> quando si batte dopo il primo carattere non-blank.  Comunque
<BS> non opererà come con 'softtabstop'.


SOLTANTO SPAZI

Se non volete affatto tabulatori nel vostro file potete impostare l'opzione
'expandtab':

	:set expandtab

Quando questa opzione è impostata il tasto <Tab> inserisce una serie di spazi.
Così otterrete la stessa quantità di spazi come se fosse stato inserito un
carattere <Tab> ma non esisterà un vero carattere <Tab> entro il vostro file.
   Il tasto backspace cancellerà uno spazio alla volta.  Così dopo aver
scritto un solo <Tab> dovrete premere <BS> otto volte per cancellarlo.  Se vi
trovate entro un'indentazione, premendo CTRL-D andrete molto più svelti.


CAMBIARE I TABULATORI IN SPAZI (E VICEVERSA)

Impostando 'expandtab' non si modificano i tabulatori esistenti.  In altri
termini ogni tabulatore nel documento resta un tabulatore.  Se desiderate
convertire i tabulatori in spazi, usate il comando ":retab".  Usate questi
comandi:

	:set expandtab
	:%retab

Adesso Vim avrà cambiato le proprie indentazioni per usare gli spazi invece
dei tabulatori.  Comunque tutti i tabulatori che vengono dopo un carattere non
spazio vuoto vengono lasciati.  Se volete convertire anche questi ultimi
agiungete un !:

	:%retab!

Ciò è un po più pericoloso perchè può cambiare i tabulatori entro una stringa.
Per vedere se ciò possa avvenire potreste usare questo:

	/"[^"\t]*\t[^"]*"

Si raccomanda di non usare tabulazioni dure entro una stringa.  Sostituitele
con "\t" per evitare problemi.

Un altro modo altrettanto valido è:

	:set noexpandtab
	:%retab!

*30.6*	Formattazione dei commenti

Una delle grandi cose di Vim è che capisce i commenti.  Potete chiedere a Vim
di formattare un commento e lui farà la cosa giusta.
   Supponiamo, ad esempio, che si abbia il seguente commento:

	/* 
	 * This is a test 
	 * of the text formatting. 
	 */ 

Potete chiedere a Vim di formattarlo ponendo il cursore all'inizio del
commento e scrivendo:

	gq]/

"gq" è l'operatore per formattare del testo.  "]/" è il movimento che vi
porterà alla fine del commento.  Il risultato sarà:

	/* 
	 * This is a test of the text formatting. 
	 */ 

Osservate come Vim abbia gestito correttamente l'inizio di ogni linea.
   Un'alternativa consiste nel selezionare il testo da formattare in
Visual mode e scrivere "gq".

Per aggiungere una nuova linea al commento ponete il cursore sulla linea di
mezzo e premete "o".  Il risultato sarà il seguente:

	/* 
	 * This is a test of the text formatting. 
	 * 
	 */ 

Vim ha inserito automaticamente un asterisco ed uno spazio al vostro posto.
Adesso potete scrivere il testo del commento.  Se esso venisse più lungo di
'textwidth', Vim andrà a capo.  Anche questa volta l'asterisco verrà inserito
automaticamente:

	/* 
	 * This is a test of the text formatting. 
	 * Typing a lot of text here will make Vim 
	 * break 
	 */ 

Affinchè ciò funzioni debbono esserci alcuni flags presenti in
'formatoptions':

	r	inserisce l'asterisco battendo <Enter> nell'Insert_mode
	o	inserisce l'asterisco usando "o" od "O" nel Normal_mode
	c	spezza il testo del commento secondo 'textwidth'

Vedere |fo-table| per ulteriori flags.


DEFINIZIONE DI UN COMMENTO

L'opzione 'comments' definisce a cosa debba assomigliare un commento.  Vim
distingue tra commenti di una sola linea e commenti che abbiano diverso
inizio, fine e parte di mezzo.
   Molti commenti su una sola linea iniziano con un carattere specifico.  In
C++vien impiegato //, nei Makefiles #, negli scripts di Vim  ".  Ad esempio
per far capire a Vim i commenti di C++:

	:set comments=://

I due punti separano i flags di un oggetto dal testo da cui si riconosce il
commento.  La forma di un oggetto in 'comments' è:

	{flags}:{text}

La parte {flags} può essere anche vuota, come ne caso attuale.
   Molti di questi oggetti possono essere concatenati, separati da virgole.
Ciò consente di riconoscere diversi tipi di commento nello stesso tempo.  Ad
esempio, modifichiamo un messaggio di e-mail.  Rispondendo, il testo scritto
da altri verrà preceduto dai caratteri ">" e "!".  Il comando funzionerebbe
così:

	:set comments=n:>,n:!

Ci sono due cose, una per i commenti che iniziano con ">" ed un'altra per
quelli che lo fanno con "!".  Entrambi usano il flag "n".  Ciò significa che
questi commenti sono annidati l'uno nell'altro.  Così una linea che cominci
con ">" può avere un altro commento dopo il ">".
Ciò consente di formattare messaggi come questo:

	> ! Did you see that site? 
	> ! It looks really great. 
	> I don't like it.  The 
	> colors are terrible. 
	What is the URL of that 
	site? 

Provate impostando 'textwidth' ad un valore diverso, e.g., 80, e formattate il
testo selezionandolo in Visual_mode e scrivendo "gq".  Il risultato sarà:

	> ! Did you see that site? It looks really great. 
	> I don't like it.  The colors are terrible. 
	What is the URL of that site? 

Noterete che Vim non sposta il testo da un tipo di commento ad un altro.  La
lettera "I" nella seconda linea potrebbe venire posta alla fine della prima
linea, ma poichè questa linea inizia con "> !" e la seconda linea con ">",
Vim sa che si tratta di un diverso tipo di commento.


COMMENTI IN TRE PARTI

Un commento C inizia con "/*", ha "*" nel mezzo e "*/" alla fine.  Si dovrà
porre in 'comments' affinchè appaia così:

	:set comments=s1:/*,mb:*,ex:*/

L'inizio è definito con "s1:/*".  La "s" indica l'inizio di un commento in tre
parti.  I due punti separano i flags dal testo da essi il commento viene
riconosciuto: "/*".  C'è un solo flag: "1".  Ciò dice a Vim che la parte
di mezzo è scostata di uno spazio.
   La parte di mezzo "mb:*" comincia con "m", che indica che si tratta di una
parte di mezzo.  Il flag "b" significa che uno spazio vuoto deve seguire il
testo.  Altrimenti Vim potrebbe considerare testo come "*pointer" come il
mezzo di un commento.
   La parte finale "ex:*/" viene identificata da una "e".  Il flag "x" ha un
significato speciale.  Significa che Vim inserirà dopo un asterisco
automaticamente, scrivendo / eliminerà gli spazi di troppo.

Per ulteriori dettagli vedere |format-comments|.

Capitolo seguente: |usr_31|  Sfruttare la GUI

Copyright: vedere |manual-copyright|  vim:tw=78:ts=8:ft=help:norl:

Segnalare refusi a Bartolomeo Ravera - E-mail: barrav at libero.it

Generated by vim2html on Thu Jun 17 12:17:02 CEST 2004