The_ouroboros
31-01-2013, 12:11
Ispirato da sottovento (http://www.hwupgrade.it/forum/showpost.php?p=38952425&postcount=54)... ecco qui il 3d :D
Fatevi sotto :fagiano:
Fatevi sotto :fagiano:
View Full Version : [G?Vim?] Trucchi e problemi
Vincenzo1968
31-01-2013, 12:16
Iscritto!
:yeah: :winner: :yeah:
:yeah: :winner: :yeah:
The_ouroboros
31-01-2013, 12:19
il titolo ha una particolarità... chi l'ha notata? :D
Vincenzo1968
31-01-2013, 12:20
il titolo ha una particolarità... chi l'ha notata? :D
Cos'è un'espressione regolare? :mbe:
:D
Cos'è un'espressione regolare? :mbe:
:D
sottovento
31-01-2013, 12:20
1 - sei un grande!
2 - un mio collega aveva un file xml contenente un milioncino di record del tipo:
<data>
<Number>0</Number>
<aaa>aaa</aaa>
<bbb>bbb</bbb>
<ccc>ccc<cccb>
.....
</data>
vale a dire, un tag Number che fungeva da id e poi una serie di informazioni relative a detto record.
Si e' poi reso conto che tutti i valori in <Number> dovevano essere incrementati di uno. E lo stava facendo a mano.
Il suggerimento e' stato:
:1,$g/^<Number>.*$/s/[0-9][0-9]*/\=(submatch(0)+1)
3 - Se il thread diventa interessante, sarebbe opportuno che un amministratore lo lasci fisso in prima pagina (chiedo scusa a chi non e' interessato a questo editor....)
2 - un mio collega aveva un file xml contenente un milioncino di record del tipo:
<data>
<Number>0</Number>
<aaa>aaa</aaa>
<bbb>bbb</bbb>
<ccc>ccc<cccb>
.....
</data>
vale a dire, un tag Number che fungeva da id e poi una serie di informazioni relative a detto record.
Si e' poi reso conto che tutti i valori in <Number> dovevano essere incrementati di uno. E lo stava facendo a mano.
Il suggerimento e' stato:
:1,$g/^<Number>.*$/s/[0-9][0-9]*/\=(submatch(0)+1)
3 - Se il thread diventa interessante, sarebbe opportuno che un amministratore lo lasci fisso in prima pagina (chiedo scusa a chi non e' interessato a questo editor....)
The_ouroboros
31-01-2013, 12:20
Cos'è un'espressione regolare? :mbe:
:D
yup :cool:
:D
yup :cool:
The_ouroboros
31-01-2013, 12:22
:1,$g/^<Number>.*$/s/[0-9][0-9]*/\=(submatch(0)+1)
Bellino :)
Bellino :)
sottovento
31-01-2013, 12:28
Bellino :)
Devi pagarmi :D aspetto i tuoi segreti.
Intanto aggiungo un trucchetto semplice semplice per i fruitori di questo meraviglioso sito di cui non ricordo il nome (dai, scherzo, e' scritto in alto):
spesso alcuni postatori folli chiedono aiuto su una porzione di codice, e semplicemente lo copiano ed incollano nel post, senza includerlo nell'apposito tag. Il risultato e' che il codice perde tutta l'indentazione e molti si rifiutano di leggere una cosa del genere.
Il problema e' facilmente risolvibile incollando il codice in gvim e scrivendo
=G
voila'
Devi pagarmi :D aspetto i tuoi segreti.
Intanto aggiungo un trucchetto semplice semplice per i fruitori di questo meraviglioso sito di cui non ricordo il nome (dai, scherzo, e' scritto in alto):
spesso alcuni postatori folli chiedono aiuto su una porzione di codice, e semplicemente lo copiano ed incollano nel post, senza includerlo nell'apposito tag. Il risultato e' che il codice perde tutta l'indentazione e molti si rifiutano di leggere una cosa del genere.
Il problema e' facilmente risolvibile incollando il codice in gvim e scrivendo
=G
voila'
Vincenzo1968
31-01-2013, 12:32
Ragazzi ve lo dico prima. Tutti questi bei problemini di cui state discutendo qui, saranno oggetto di un futuro contest.
E senza riri chisà...
;)
E senza riri chisà...
;)
The_ouroboros
31-01-2013, 12:32
:g/^$/d per cancellare le linee vuote.
In command mode o* va una linea sotto la corrente e permette l'inserimento da subito.
Invece O* porta tutto sotto di una linea e pertmette l'inserimento una linea sopra la corrente.
Spero come inizio non sia deludente :cool:
* la lettera o minuscola/maiuscola
In command mode o* va una linea sotto la corrente e permette l'inserimento da subito.
Invece O* porta tutto sotto di una linea e pertmette l'inserimento una linea sopra la corrente.
Spero come inizio non sia deludente :cool:
* la lettera o minuscola/maiuscola
The_ouroboros
31-01-2013, 12:35
oppure abbiamo la sostituzione di pattern
%s/<pattern old>/<pattern new>/gc
Con g lo fa globalmente e con c chiede la conferma
O anche la semplice ricerca id termine con
/termine
Oppure, più veloce, ti porti sulla word che vuoi e usi # per cercarla nel testo
%s/<pattern old>/<pattern new>/gc
Con g lo fa globalmente e con c chiede la conferma
O anche la semplice ricerca id termine con
/termine
Oppure, più veloce, ti porti sulla word che vuoi e usi # per cercarla nel testo
The_ouroboros
31-01-2013, 12:43
E cosa dire del fatto che è possibile integrare comandi vi in uno script bash?
P.S: Vim on Win32 (http://blog.paracode.com/2011/06/11/vim-on-windows/)
P.S: Vim on Win32 (http://blog.paracode.com/2011/06/11/vim-on-windows/)
shinya
31-01-2013, 12:44
E' una cagata, ma lo uso spesso.
Per scambiare due righe tra loro:ddp
Per scambiare due righe tra loro:ddp
sottovento
31-01-2013, 12:48
Si, lo conoscevo ma hai fatto piu' che benissimo a riportare questo trucco, a favore di chi passera' di qui. Non mi hai ancora pagato, pero' (so che hai una lista da qualche parte che non vuoi condividere. Voglio quella :D )
Visto che ci siamo, torniamo sul copy and paste: vi mette a disposizione 26 +1 blocchi per appunti. L'1 e' quello anonimo, in cui copi se non specifichi nient'altro. Altrimenti puoi riferirti ad un blocco appunti ben specifico, il quale e' identificato con una lettera dell'alfabeto.
Riprendendo quello che ha detto The_ouroboros, con
yy
(o semplicemente con Y)
copy una riga. Si puo' anteporre il nome del buffer/blocco appunti mediante il carattere ", per esempio:
"aY
copia una riga nel buffer a
Questo e' comodissimo quando, per esempio, si va in giro per il codice a cercare i pezzi di testo da incollare poi da un'altra parte. Invece che spostarsi continuamente avanti e indietro, si puo' copiare ogni parte in un buffer diverso e poi andare a destinazione e copiarli tutti con
"ap
(o con "aP, come spiegato da The_ouroboros).
Si ricorda che ai comandi puo' essere anteposto un numero, per esempio:
"c100Y
copia 100 righe nel buffer c
Visto che ci siamo, torniamo sul copy and paste: vi mette a disposizione 26 +1 blocchi per appunti. L'1 e' quello anonimo, in cui copi se non specifichi nient'altro. Altrimenti puoi riferirti ad un blocco appunti ben specifico, il quale e' identificato con una lettera dell'alfabeto.
Riprendendo quello che ha detto The_ouroboros, con
yy
(o semplicemente con Y)
copy una riga. Si puo' anteporre il nome del buffer/blocco appunti mediante il carattere ", per esempio:
"aY
copia una riga nel buffer a
Questo e' comodissimo quando, per esempio, si va in giro per il codice a cercare i pezzi di testo da incollare poi da un'altra parte. Invece che spostarsi continuamente avanti e indietro, si puo' copiare ogni parte in un buffer diverso e poi andare a destinazione e copiarli tutti con
"ap
(o con "aP, come spiegato da The_ouroboros).
Si ricorda che ai comandi puo' essere anteposto un numero, per esempio:
"c100Y
copia 100 righe nel buffer c
The_ouroboros
31-01-2013, 12:51
Si, lo conoscevo ma hai fatto piu' che benissimo a riportare questo trucco, a favore di chi passera' di qui. Non mi hai ancora pagato, pero' (so che hai una lista da qualche parte che non vuoi condividere. Voglio quella :D )
Ottimo :D
Diciamo che io combino le mie conoscenze di awk+perl+grep+sed e le riverso in vi.
E molto uso le regexp.
Sono un sysadmin molto strano, lo ammetto. :stordita:
Ottimo :D
Diciamo che io combino le mie conoscenze di awk+perl+grep+sed e le riverso in vi.
E molto uso le regexp.
Sono un sysadmin molto strano, lo ammetto. :stordita:
sottovento
31-01-2013, 12:57
I comandi di vi si possono facilmente combinare fra di loro, offrendo una notevole flessibilita'.
Come esempio e' necessario introdurre i mark. I mark sono delle "bandierine" che si possono mettere nel testo per tornare velocemente in una posizione prefissata. Molti editor l'hanno, ma occorre staccarsi dalla tastiera e usare il mouse. In vi sono integrati.
Se si vuole marcare una linea, basta il comando m seguito dal nome del mark (lettera a...z).
Esempio:
ma
volendo tornare al punto marcato, si puo' usare l'apice,
'a
Naturalmente si abusa dell'uso del mark m, perche' mm e' facilissimo, cosi' come 'm
Supponiamo ora di voler copiare un blocco di linee senza volerle contare, normalmente marco l'inizio con ma, poi cerco la fine del blocco e lo marco con mm.
Dopo di che con 'a torno all'inizio del blocco e poi lo copio con
y'm
Ovviamente posso specificare un buffer:
"ay'm
E posso usare i mark anche durante una sostituzioe, per esempio:
:'a,'ms/questo/quello/g
Come esempio e' necessario introdurre i mark. I mark sono delle "bandierine" che si possono mettere nel testo per tornare velocemente in una posizione prefissata. Molti editor l'hanno, ma occorre staccarsi dalla tastiera e usare il mouse. In vi sono integrati.
Se si vuole marcare una linea, basta il comando m seguito dal nome del mark (lettera a...z).
Esempio:
ma
volendo tornare al punto marcato, si puo' usare l'apice,
'a
Naturalmente si abusa dell'uso del mark m, perche' mm e' facilissimo, cosi' come 'm
Supponiamo ora di voler copiare un blocco di linee senza volerle contare, normalmente marco l'inizio con ma, poi cerco la fine del blocco e lo marco con mm.
Dopo di che con 'a torno all'inizio del blocco e poi lo copio con
y'm
Ovviamente posso specificare un buffer:
"ay'm
E posso usare i mark anche durante una sostituzioe, per esempio:
:'a,'ms/questo/quello/g
The_ouroboros
31-01-2013, 13:00
dimenticavamo il graal di non muoversi troppo con le dita
h, j, k ed l (sinistra, giù, su, destra).
h, j, k ed l (sinistra, giù, su, destra).
Vincenzo1968
31-01-2013, 13:37
:yeah: :winner: :yeah:
The_ouroboros
31-01-2013, 14:01
come va la tua esplorazione di vi?
Vincenzo1968
31-01-2013, 14:07
No, per il momento, fra lavoro e contest, non posso occuparmene. Ma questo thread mi tornerà utilissimo in futuro.
Grazie di cuore a tutti voi ;)
Grazie di cuore a tutti voi ;)
sottovento
01-02-2013, 04:19
Un comando interessante e' la ricerca sulla stessa linea mediante il tasto f (oppure F per andare verso l'inizio della linea).
Permette di cercare un carattere, per esempio
fa
si posizionera' sulla prima a disponibile.
5fa
si posizionera' sulla quinta a disponibile.
Questo e' estremamente comodo per spostarsi sulle righe, soprattutto quando sono lunghe. Se per esempio ci sono molte frasi sulla stessa linea (senza un new line in mezzo), allora
f.
mi permette di andare alla frase successiva.
Inoltre il comando ; mi permette di ripetere l'ultima ricerca. Quindi se prima ho impostato
f.
poi mediante ; andro' alle frasi successive.
La capacita' di vi di combinare i comandi rende questo comando piu' interessante.
Per esempio:
yf.
copiera' l'intera frase nel buffer, pronto per un paste in un'altra parte del testo.
Ovviamente posso specificare anche quale buffer voglio usare, per esempio:
"ay5f.
copiera' nel buffer a le successive 5 frasi (ammesso che ci siano, altrimenti non fara' nulla).
Permette di cercare un carattere, per esempio
fa
si posizionera' sulla prima a disponibile.
5fa
si posizionera' sulla quinta a disponibile.
Questo e' estremamente comodo per spostarsi sulle righe, soprattutto quando sono lunghe. Se per esempio ci sono molte frasi sulla stessa linea (senza un new line in mezzo), allora
f.
mi permette di andare alla frase successiva.
Inoltre il comando ; mi permette di ripetere l'ultima ricerca. Quindi se prima ho impostato
f.
poi mediante ; andro' alle frasi successive.
La capacita' di vi di combinare i comandi rende questo comando piu' interessante.
Per esempio:
yf.
copiera' l'intera frase nel buffer, pronto per un paste in un'altra parte del testo.
Ovviamente posso specificare anche quale buffer voglio usare, per esempio:
"ay5f.
copiera' nel buffer a le successive 5 frasi (ammesso che ci siano, altrimenti non fara' nulla).
Vincenzo1968
01-02-2013, 09:52
Devi pagarmi :D aspetto i tuoi segreti.
Intanto aggiungo un trucchetto semplice semplice per i fruitori di questo meraviglioso sito di cui non ricordo il nome (dai, scherzo, e' scritto in alto):
spesso alcuni postatori folli chiedono aiuto su una porzione di codice, e semplicemente lo copiano ed incollano nel post, senza includerlo nell'apposito tag. Il risultato e' che il codice perde tutta l'indentazione e molti si rifiutano di leggere una cosa del genere.
Il problema e' facilmente risolvibile incollando il codice in gvim e scrivendo
=G
voila'
Meraviglioso!
Con il codice non indentato di Sam:
http://www.hwupgrade.it/forum/showpost.php?p=38932821&postcount=1
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct nomi{
char *n;
nomi *suc;
};
int main()
{
nomi *inizio,*lista;
char *a;
int i,n;
printf("Quanti nomi vuoi inserire?--> ");
scanf("%d",&n);
system("cls");
printf("Inseire prima stringa");
fflush(stdin);
a=(char*)malloc(sizeof(char));
gets(a);
inizio=(nomi*)malloc(sizeof(nomi));
inizio->n=(char*)malloc(strlen(a)*sizeof(char)+1);
strcpy(inizio->n,a);
lista=inizio;
for(i=1; i<n; i++){
system("cls");
a=(char*)malloc(sizeof(char));
lista->suc=(nomi*)malloc(sizeof(nomi));
lista=lista->suc;
printf("%d nome : ",i+1);
gets(a);
lista->n=(char*)malloc(strlen(a)*sizeof(char)+1);
strcpy(lista->n,a);
}
lista->suc=NULL;
fflush(stdin);
...
...
...
ecco quello che succede:
http://img43.imageshack.us/img43/9985/gvim.jpg
:yeah: :winner: :yeah:
Intanto aggiungo un trucchetto semplice semplice per i fruitori di questo meraviglioso sito di cui non ricordo il nome (dai, scherzo, e' scritto in alto):
spesso alcuni postatori folli chiedono aiuto su una porzione di codice, e semplicemente lo copiano ed incollano nel post, senza includerlo nell'apposito tag. Il risultato e' che il codice perde tutta l'indentazione e molti si rifiutano di leggere una cosa del genere.
Il problema e' facilmente risolvibile incollando il codice in gvim e scrivendo
=G
voila'
Meraviglioso!
Con il codice non indentato di Sam:
http://www.hwupgrade.it/forum/showpost.php?p=38932821&postcount=1
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct nomi{
char *n;
nomi *suc;
};
int main()
{
nomi *inizio,*lista;
char *a;
int i,n;
printf("Quanti nomi vuoi inserire?--> ");
scanf("%d",&n);
system("cls");
printf("Inseire prima stringa");
fflush(stdin);
a=(char*)malloc(sizeof(char));
gets(a);
inizio=(nomi*)malloc(sizeof(nomi));
inizio->n=(char*)malloc(strlen(a)*sizeof(char)+1);
strcpy(inizio->n,a);
lista=inizio;
for(i=1; i<n; i++){
system("cls");
a=(char*)malloc(sizeof(char));
lista->suc=(nomi*)malloc(sizeof(nomi));
lista=lista->suc;
printf("%d nome : ",i+1);
gets(a);
lista->n=(char*)malloc(strlen(a)*sizeof(char)+1);
strcpy(lista->n,a);
}
lista->suc=NULL;
fflush(stdin);
...
...
...
ecco quello che succede:
http://img43.imageshack.us/img43/9985/gvim.jpg
:yeah: :winner: :yeah:
sottovento
01-02-2013, 09:57
Spesso succede di copiare del testo da un sistema all'altro, (oppure da internet) e di trovarsi tutto il testo su un'unica riga.
Praticamente inservibile.
Una soluzione, in questi casi, potrebbe essere quella di inserire automaticamente un carattere di a capo subito dopo il punto:
:1,$s/\./.\r/g
In molti casi e' invece molto piu' utile spezzare le linee ad una dimensione fissa introducendo il carattere di a capo.
Per esempio, volendo mandare a capo le righe piu' lunghe di 80 caratteri scriveremo:
:1,$s/.\{80}/&\r/g
In quest'ultima sostituzione si puo' vedere un trucco che avremo modo di approfondire :D
Praticamente inservibile.
Una soluzione, in questi casi, potrebbe essere quella di inserire automaticamente un carattere di a capo subito dopo il punto:
:1,$s/\./.\r/g
In molti casi e' invece molto piu' utile spezzare le linee ad una dimensione fissa introducendo il carattere di a capo.
Per esempio, volendo mandare a capo le righe piu' lunghe di 80 caratteri scriveremo:
:1,$s/.\{80}/&\r/g
In quest'ultima sostituzione si puo' vedere un trucco che avremo modo di approfondire :D
sottovento
01-02-2013, 10:00
Meraviglioso!
Con il codice non indentato di Sam:
:yeah: :winner: :yeah:
Penso che questo sia il modo migliore per imparare vi: tenersi un piccolo "how to" a portata di mano. Cosi' quando un'operazione diventa difficile con un altro editor, si passa a vi, apprezzandolo ;)
Con il codice non indentato di Sam:
:yeah: :winner: :yeah:
Penso che questo sia il modo migliore per imparare vi: tenersi un piccolo "how to" a portata di mano. Cosi' quando un'operazione diventa difficile con un altro editor, si passa a vi, apprezzandolo ;)
Vincenzo1968
01-02-2013, 10:06
E come si fa a non apprezzarlo? :D
Ma la G in GVim sta per graphical? È questa la differenza con Vim? E Vi in cosa differisce dai primi due?
Ma la G in GVim sta per graphical? È questa la differenza con Vim? E Vi in cosa differisce dai primi due?
The_ouroboros
01-02-2013, 10:06
oggi avevo un collega con 1054 record a cui togliere gli spazi e non sapeva come muoversi
Esportato in txt, passato a vi un bel %s/ //g e passa la paura.
:D
Esportato in txt, passato a vi un bel %s/ //g e passa la paura.
:D
The_ouroboros
01-02-2013, 10:07
E come si fa a non apprezzarlo? :D
Ma la G in GVim sta per graphical? È questa la differenza con Vim? E Vi in cosa differisce dai primi due?
Vi originale
Vim = Vi Improved
Su gvim non saprei dirti. :stordita:
Ma la G in GVim sta per graphical? È questa la differenza con Vim? E Vi in cosa differisce dai primi due?
Vi originale
Vim = Vi Improved
Su gvim non saprei dirti. :stordita:
Vincenzo1968
01-02-2013, 10:12
oggi avevo un collega con 1054 record a cui togliere gli spazi e non sapeva come muoversi
Esportato in txt, passato a vi un bel %s/ //g e passa la paura.
:D
Ma in sostanza sono i comandi che usa Marco.r per la sua soluzione del punto A nel contest 19?
Questo è il codice di Marco:
Marcor.sh:
#!/bin/sh
SIZE=$(echo $2 | sed 's/G/ * 1000 M/;s/M/ * 1000 K/;s/K/ * 1000/;s/$/ +\\/; $a0' | bc)
BS=1000000
COUNT=$(echo 1 + $SIZE / $BS | bc )
OUTPUT=$1
echo > $OUTPUT
cat All/*.txt | sed -e 's/\s\+/ /g' | grep -v '^\s*$' > text.dat
while $(test `stat --format '%s' $OUTPUT` -lt $SIZE )
do
shuf text.dat | dd bs=$BS iflag=fullblock count=$COUNT >> $OUTPUT
done
truncate -s $SIZE $OUTPUT
O non c'entra niente?
Esportato in txt, passato a vi un bel %s/ //g e passa la paura.
:D
Ma in sostanza sono i comandi che usa Marco.r per la sua soluzione del punto A nel contest 19?
Questo è il codice di Marco:
Marcor.sh:
#!/bin/sh
SIZE=$(echo $2 | sed 's/G/ * 1000 M/;s/M/ * 1000 K/;s/K/ * 1000/;s/$/ +\\/; $a0' | bc)
BS=1000000
COUNT=$(echo 1 + $SIZE / $BS | bc )
OUTPUT=$1
echo > $OUTPUT
cat All/*.txt | sed -e 's/\s\+/ /g' | grep -v '^\s*$' > text.dat
while $(test `stat --format '%s' $OUTPUT` -lt $SIZE )
do
shuf text.dat | dd bs=$BS iflag=fullblock count=$COUNT >> $OUTPUT
done
truncate -s $SIZE $OUTPUT
O non c'entra niente?
sottovento
01-02-2013, 10:13
Vi originale
Vim = Vi Improved
Su gvim non saprei dirti. :stordita:
La g dovrebbe essere "gnu", ma non ne sono sicuro.
Visto che ci sono: alcuni IDE danno la possibilita' di commentare/scommentare una porzione di codice. Non sapendo ne' leggere ne' scrivere potremmo marcare la riga finale del blocco da commentare, per esempio con
mm
poi potremmo portarci all'inizio del blocco e digitare:
:.,'ms/^/\/\//
Per scommentarlo, una volta marcato ancora con m la fine del blocco ed essendo ad inizio blocco, basta digitare:
:.,'ms/^..//
Vim = Vi Improved
Su gvim non saprei dirti. :stordita:
La g dovrebbe essere "gnu", ma non ne sono sicuro.
Visto che ci sono: alcuni IDE danno la possibilita' di commentare/scommentare una porzione di codice. Non sapendo ne' leggere ne' scrivere potremmo marcare la riga finale del blocco da commentare, per esempio con
mm
poi potremmo portarci all'inizio del blocco e digitare:
:.,'ms/^/\/\//
Per scommentarlo, una volta marcato ancora con m la fine del blocco ed essendo ad inizio blocco, basta digitare:
:.,'ms/^..//
sottovento
01-02-2013, 10:15
Ma in sostanza sono i comandi che usa Marco.r per la sua soluzione del punto A nel contest 19?
Questo è il codice di Marco:
Marcor.sh:
#!/bin/sh
SIZE=$(echo $2 | sed 's/G/ * 1000 M/;s/M/ * 1000 K/;s/K/ * 1000/;s/$/ +\\/; $a0' | bc)
BS=1000000
COUNT=$(echo 1 + $SIZE / $BS | bc )
OUTPUT=$1
echo > $OUTPUT
cat All/*.txt | sed -e 's/\s\+/ /g' | grep -v '^\s*$' > text.dat
while $(test `stat --format '%s' $OUTPUT` -lt $SIZE )
do
shuf text.dat | dd bs=$BS iflag=fullblock count=$COUNT >> $OUTPUT
done
truncate -s $SIZE $OUTPUT
O non c'entra niente?
L'hai detta giusta. Si tratta sempre di espressioni regolari.
Questo è il codice di Marco:
Marcor.sh:
#!/bin/sh
SIZE=$(echo $2 | sed 's/G/ * 1000 M/;s/M/ * 1000 K/;s/K/ * 1000/;s/$/ +\\/; $a0' | bc)
BS=1000000
COUNT=$(echo 1 + $SIZE / $BS | bc )
OUTPUT=$1
echo > $OUTPUT
cat All/*.txt | sed -e 's/\s\+/ /g' | grep -v '^\s*$' > text.dat
while $(test `stat --format '%s' $OUTPUT` -lt $SIZE )
do
shuf text.dat | dd bs=$BS iflag=fullblock count=$COUNT >> $OUTPUT
done
truncate -s $SIZE $OUTPUT
O non c'entra niente?
L'hai detta giusta. Si tratta sempre di espressioni regolari.
The_ouroboros
01-02-2013, 10:18
Ma in sostanza sono i comandi che usa Marco.r per la sua soluzione del punto A nel contest 19?
O non c'entra niente?
Ha usato sed(stream editor, successore di ed) che compie azioni in baso a regex* che gli passi :D
Anche vi le supporta :fagiano:
* ci vorrebbe un 3d solo per queste.
O non c'entra niente?
Ha usato sed(stream editor, successore di ed) che compie azioni in baso a regex* che gli passi :D
Anche vi le supporta :fagiano:
* ci vorrebbe un 3d solo per queste.
Vincenzo1968
01-02-2013, 10:21
Raga', visto che Marco c'è e non c'è, appare e subito scompare, mi dareste una veloce spiegazione dei comandi contenuti nel suo .sh?
The_ouroboros
01-02-2013, 10:26
#!/bin/sh
SIZE=$(echo $2 | sed 's/G/ * 1000 M/;s/M/ * 1000 K/;s/K/ * 1000/;s/$/ +\\/; $a0' | bc) # (1)
BS=1000000
COUNT=$(echo 1 + $SIZE / $BS | bc ) # usa bc(una "colcolatrice") per fare operazioni
OUTPUT=$1
echo > $OUTPUT
cat All/*.txt | sed -e 's/\s\+/ /g' | grep -v '^\s*$' > text.dat (2)
while $(test `stat --format '%s' $OUTPUT` -lt $SIZE )
do
shuf text.dat | dd bs=$BS iflag=fullblock count=$COUNT >> $OUTPUT (3)
done
truncate -s $SIZE $OUTPUT
(1) prende il secondo argomento della cli e poi ffettua dei cambi di unità di misura: GiB ->GB MiB -> MB e poi calcola la somma della dimensione.
(2) legge tutti i file txt e poi toglie gli spazi con sed e prende le linee che non cominciano con uno spazio con grep ( -v prende le linee che non rispettano la regex).
(3) Shuffla il file di out e poi lo scrive.
SIZE=$(echo $2 | sed 's/G/ * 1000 M/;s/M/ * 1000 K/;s/K/ * 1000/;s/$/ +\\/; $a0' | bc) # (1)
BS=1000000
COUNT=$(echo 1 + $SIZE / $BS | bc ) # usa bc(una "colcolatrice") per fare operazioni
OUTPUT=$1
echo > $OUTPUT
cat All/*.txt | sed -e 's/\s\+/ /g' | grep -v '^\s*$' > text.dat (2)
while $(test `stat --format '%s' $OUTPUT` -lt $SIZE )
do
shuf text.dat | dd bs=$BS iflag=fullblock count=$COUNT >> $OUTPUT (3)
done
truncate -s $SIZE $OUTPUT
(1) prende il secondo argomento della cli e poi ffettua dei cambi di unità di misura: GiB ->GB MiB -> MB e poi calcola la somma della dimensione.
(2) legge tutti i file txt e poi toglie gli spazi con sed e prende le linee che non cominciano con uno spazio con grep ( -v prende le linee che non rispettano la regex).
(3) Shuffla il file di out e poi lo scrive.
Vincenzo1968
01-02-2013, 10:46
Ok, grazie mille.
Quindi ha usato sed. Come al solito, su Linux, c'è solo l'imbarazzo della scelta. :D
Quindi ha usato sed. Come al solito, su Linux, c'è solo l'imbarazzo della scelta. :D
The_ouroboros
01-02-2013, 11:28
dovevo aggiungere qualcosa all'inizio e alla fine di ogni riga di un file (1500 righe).
Soluzione che ho pensato con vi
%s/^/#/g
Mette all'inizio di ogni riga #
%s/#/<pattern>/g
Lo sostituisce.
Per la fine riga
%s/$/<pattern>/g
E in un microsecondo tutto sistemato :D
Soluzione che ho pensato con vi
%s/^/#/g
Mette all'inizio di ogni riga #
%s/#/<pattern>/g
Lo sostituisce.
Per la fine riga
%s/$/<pattern>/g
E in un microsecondo tutto sistemato :D
sottovento
01-02-2013, 11:35
dovevo aggiungere qualcosa all'inizio e alla fine di ogni riga di un file (1500 righe).
Soluzione che ho pensato con vi
%s/^/#/g
Mette all'inizio di ogni riga #
%s/#/<pattern>/g
Lo sostituisce.
Per la fine riga
%s/$/<pattern>/g
E in un microsecondo tutto sistemato :D
Puoi fare anche di meglio:
:%s/^.*$/pattern_inizio&pattern_fine/
(il passaggio al # temporaneo poteva essere evitato :D )
Soluzione che ho pensato con vi
%s/^/#/g
Mette all'inizio di ogni riga #
%s/#/<pattern>/g
Lo sostituisce.
Per la fine riga
%s/$/<pattern>/g
E in un microsecondo tutto sistemato :D
Puoi fare anche di meglio:
:%s/^.*$/pattern_inizio&pattern_fine/
(il passaggio al # temporaneo poteva essere evitato :D )
VICIUS
01-02-2013, 11:42
Vim Adventures (http://vim-adventures.com)
Un sito carino in cui mi sono imbattuto tempo fa.
Un sito carino in cui mi sono imbattuto tempo fa.
The_ouroboros
01-02-2013, 13:22
Puoi fare anche di meglio:
:%s/^.*$/pattern_inizio&pattern_fine/
(il passaggio al # temporaneo poteva essere evitato :D )
buono a sapersi ;)
:%s/^.*$/pattern_inizio&pattern_fine/
(il passaggio al # temporaneo poteva essere evitato :D )
buono a sapersi ;)
sottovento
01-02-2013, 20:37
Un altro comando allettante e' il comando v dato a livello dei due punti (i.e. disponibile anche in ed/sed).
Come sempre, si puo' specificare un intervallo di linee sul quale deve agire, e permette di modificare le linee che NON fanno il paio con il pattern.
E' quindi utilissimo per filtrare via le parti che non interessano.
Per esempio, supponiamo di aprire un file di log in cui scrivono tutti i processi che compongono la mia applicazione, qualcosa del genere
data_handler: handling data #1203984
dispatcher: sending text #2309823 to OPM
mailer: checking for incoming messages
....
Supponiamo che questo file sia lungo 10 milioni di linee e che il nostro interesse sia solo per il dispatcher.
Potremmo impartire il comando
:1,$v/^dispatcher/d
e cancelleremmo di colpo tutte le linee che non iniziano per dispatcher
Come sempre, si puo' specificare un intervallo di linee sul quale deve agire, e permette di modificare le linee che NON fanno il paio con il pattern.
E' quindi utilissimo per filtrare via le parti che non interessano.
Per esempio, supponiamo di aprire un file di log in cui scrivono tutti i processi che compongono la mia applicazione, qualcosa del genere
data_handler: handling data #1203984
dispatcher: sending text #2309823 to OPM
mailer: checking for incoming messages
....
Supponiamo che questo file sia lungo 10 milioni di linee e che il nostro interesse sia solo per il dispatcher.
Potremmo impartire il comando
:1,$v/^dispatcher/d
e cancelleremmo di colpo tutte le linee che non iniziano per dispatcher
The_ouroboros
01-02-2013, 21:17
l'ho sempre detto che vi prende il meglio di grep e sed :cool:
The_ouroboros
02-02-2013, 09:46
ho trovato uno sperimentale Vi per Win32 (http://winvi.de/en/):D
sottovento
03-02-2013, 08:05
Durante una sostituzione con il comando s, il carattere speciale & contiene quanto trovato, e puo' essere utilizzato durante la sostituzione. Un semplice accorgimento permette una grande potenzialita'.
Per esempio:
:1,$s/[A-Z][a-z]*/Signor &/g
cerchera' tutti i nomi che cominciano con una maiuscola e li sostituira' con loro stessi, preceduti da Signor.
Su un testo del tipo
Maurizio qui e' Sottovento che vuole invitare te, Cesare e Luca per una pizza.
si otterra'
Signor Maurizio qui e' Signor Sottovento che vuole invitare te, Signor Cesare e Signor Luca per una pizza.
(esempio un po' stupido ma credo sia chiara l'utilita' di questa cosa)
Per esempio:
:1,$s/[A-Z][a-z]*/Signor &/g
cerchera' tutti i nomi che cominciano con una maiuscola e li sostituira' con loro stessi, preceduti da Signor.
Su un testo del tipo
Maurizio qui e' Sottovento che vuole invitare te, Cesare e Luca per una pizza.
si otterra'
Signor Maurizio qui e' Signor Sottovento che vuole invitare te, Signor Cesare e Signor Luca per una pizza.
(esempio un po' stupido ma credo sia chiara l'utilita' di questa cosa)
The_ouroboros
03-02-2013, 09:50
anche in sed e grep funziona come matched expression.
In Perl invece hai le variabili "automatiche" $& per la stringa matched e $` per prima e $' per dopo (anche se hanno un leggero overhead.)
In Perl invece hai le variabili "automatiche" $& per la stringa matched e $` per prima e $' per dopo (anche se hanno un leggero overhead.)
Vincenzo1968
03-02-2013, 11:01
ho trovato uno sperimentale Vi per Win32 (http://winvi.de/en/):D
Più tardi lo "esperimento" su Windows. :D
Più tardi lo "esperimento" su Windows. :D
sottovento
03-02-2013, 12:32
Spesso i neofiti di vim non sanno come congiungere due linee, quella corrente e la successiva. Per esempio, si e' inavvertitamente premuto enter e si e' andati a capo; come fare?
Ovviamente esiste il comando apposito: J (maiuscola) unisce la linea corrente con la successiva.
Per inciso: alcuni spostamenti veloci con vi:
- w va alla parola successiva. 5w ovviamente andra' alla quinta parola successiva;
- b va alla parola precendente. 10b ovviamente andra' alla decima parola precedente;
- e va alla parola successiva e si posiziona alla fine della parola (al contrario di w, che si posiziona all'inizio);
- il corrispondente comando per andare alla fine della parola precedente non lo conosco :D
Il comando G manda il cursore alla fine del testo. Se si antepone un numero, si andra' alla linea desiderata, per esempio 3270G si andra' alla linea 3270.
Il comando zz (minuscole, mi raccomando) posiziona la linea corrente esattamente al centro dell'area disponibile. Utilissimo per ritrovarsi nella marea di testo.
Per chi programma in C/C++ e' interessante sapere che se si indenta in questo modo:
void func1()
{
}
void func2()
{
}
void func3()
{
}
...
ci si puo' spostare all'inizio di ogni funzione (i.e. parentesi graffa aperta ad inizio linea) tramite i comandi
[[
]]
Il primo posizionera' sulla successiva funzione, mentre il secondo sulla precedente.
Ovviamente esiste il comando apposito: J (maiuscola) unisce la linea corrente con la successiva.
Per inciso: alcuni spostamenti veloci con vi:
- w va alla parola successiva. 5w ovviamente andra' alla quinta parola successiva;
- b va alla parola precendente. 10b ovviamente andra' alla decima parola precedente;
- e va alla parola successiva e si posiziona alla fine della parola (al contrario di w, che si posiziona all'inizio);
- il corrispondente comando per andare alla fine della parola precedente non lo conosco :D
Il comando G manda il cursore alla fine del testo. Se si antepone un numero, si andra' alla linea desiderata, per esempio 3270G si andra' alla linea 3270.
Il comando zz (minuscole, mi raccomando) posiziona la linea corrente esattamente al centro dell'area disponibile. Utilissimo per ritrovarsi nella marea di testo.
Per chi programma in C/C++ e' interessante sapere che se si indenta in questo modo:
void func1()
{
}
void func2()
{
}
void func3()
{
}
...
ci si puo' spostare all'inizio di ogni funzione (i.e. parentesi graffa aperta ad inizio linea) tramite i comandi
[[
]]
Il primo posizionera' sulla successiva funzione, mentre il secondo sulla precedente.
The_ouroboros
03-02-2013, 12:48
ci si puo' spostare all'inizio di ogni funzione (i.e. parentesi graffa aperta ad inizio linea) tramite i comandi
[[
]]
Il primo posizionera' sulla successiva funzione, mentre il secondo sulla precedente.
Anche con %
[[
]]
Il primo posizionera' sulla successiva funzione, mentre il secondo sulla precedente.
Anche con %
sottovento
03-02-2013, 13:00
Anche con %
Con % si passa da una parentesi aperta alla corrispondente chiusa, e viceversa, indipendentemente dal tipo della parentesi (i.e. tonda, quadra, graffa).
I comandi [[ e ]] si spostano solo alla parentesi graffa aperta ad inizio linea. Con un'opportuna indentazione e' quindi possibile muoversi da funzione a funzione, e' un po' diverso.
Ovviamente grazie alla capacita' di vi di combinare i comandi, e' possibile ottenere effetti simpatici, per esempio:
y% copiera' il testo fra le parentesi aperta/chiusa. Se posizionati sulla prima parentesi graffa di una funzione, copiera' l'intero body della funzione.
Con % si passa da una parentesi aperta alla corrispondente chiusa, e viceversa, indipendentemente dal tipo della parentesi (i.e. tonda, quadra, graffa).
I comandi [[ e ]] si spostano solo alla parentesi graffa aperta ad inizio linea. Con un'opportuna indentazione e' quindi possibile muoversi da funzione a funzione, e' un po' diverso.
Ovviamente grazie alla capacita' di vi di combinare i comandi, e' possibile ottenere effetti simpatici, per esempio:
y% copiera' il testo fra le parentesi aperta/chiusa. Se posizionati sulla prima parentesi graffa di una funzione, copiera' l'intero body della funzione.
The_ouroboros
03-02-2013, 13:04
I comandi [[ e ]] si spostano solo alla parentesi graffa aperta ad inizio linea. Con un'opportuna indentazione e' quindi possibile muoversi da funzione a funzione, e' un po' diverso.
:D
:D
sottovento
04-02-2013, 05:25
Mi piacerebbe ora parlare del comando g ma penso di saperne troppo poco.
In pratica, g permette di fare delle ricerche e di applicare un comando alle linee trovate.
Io conosco solo tre comandi: d, s, j. Spero che qualcuno di voi ne conosca di piu' poiche' il comando e' davvero potente.
Esempio:
:1,$g/questo/d
cerca tutte le linee che contengono questo e le cancella
:1,$g/questo/j
cerca tutte le linee che contengono questo e le concatena con la riga successiva
s invece e' per fare una sostituzione nelle linee trovate:
:1,%g/questo/s/qui/qua
cerca tutte le linee che contengono questo. Nella linea selezionata cerchera' poi qui e lo sostituira' con qua.
Qualcun altro conosce qualche altro comando da impartire a livello di g?
In pratica, g permette di fare delle ricerche e di applicare un comando alle linee trovate.
Io conosco solo tre comandi: d, s, j. Spero che qualcuno di voi ne conosca di piu' poiche' il comando e' davvero potente.
Esempio:
:1,$g/questo/d
cerca tutte le linee che contengono questo e le cancella
:1,$g/questo/j
cerca tutte le linee che contengono questo e le concatena con la riga successiva
s invece e' per fare una sostituzione nelle linee trovate:
:1,%g/questo/s/qui/qua
cerca tutte le linee che contengono questo. Nella linea selezionata cerchera' poi qui e lo sostituira' con qua.
Qualcun altro conosce qualche altro comando da impartire a livello di g?
The_ouroboros
04-02-2013, 06:53
Con s, postposto per sostituzione globale.
s/qualcosa/altro/g
Senza numero linee.
Inviato dal mio LT22i con Tapatalk 2
s/qualcosa/altro/g
Senza numero linee.
Inviato dal mio LT22i con Tapatalk 2
sottovento
04-02-2013, 07:25
Ho trovato "The power of g" :D :
http://vim.wikia.com/wiki/Power_of_g
In effetti e' un comando estremamente potente
http://vim.wikia.com/wiki/Power_of_g
In effetti e' un comando estremamente potente
Vincenzo1968
04-02-2013, 16:27
Ragazzi, poiché a volte le regexp risultano di difficile comprensione, vi annuncio che prossimamente apriremo un contest col seguente problema da risolvere:
Si scriva un programmino che, presa in input una stringa contenente una regexp, la traduca in italiano.
;)
Si scriva un programmino che, presa in input una stringa contenente una regexp, la traduca in italiano.
;)
The_ouroboros
04-02-2013, 17:30
Non sono così difficili...
Inviato dal mio LT22i con Tapatalk 2
Inviato dal mio LT22i con Tapatalk 2
Vincenzo1968
04-02-2013, 17:43
Dai se ti ritrovi una regexp molto lunga vorresti farmi credere che la capisci al volo? Senza consultare la documentazione?
Gliela dai in pasto al nostro programmino e lui te la spezzetta nella varie parti e te la traduce in italiano:
L'espressione regolare X trova tutte le parole che cominciano per a e finiscono per o; inoltre trova... etc.
Comodo no?
Gliela dai in pasto al nostro programmino e lui te la spezzetta nella varie parti e te la traduce in italiano:
L'espressione regolare X trova tutte le parole che cominciano per a e finiscono per o; inoltre trova... etc.
Comodo no?
Vincenzo1968
04-02-2013, 17:49
questa, per esempio, che cosa fa?
(?:(?:\r\n)?[ \t])*(?:(?:(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t]
)+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:
\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(
?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[
\t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\0
31]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\
](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+
(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:
(?:\r\n)?[ \t])*))*|(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z
|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)
?[ \t])*)*\<(?:(?:\r\n)?[ \t])*(?:@(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\
r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[
\t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)
?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t]
)*))*(?:,@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[
\t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*
)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t]
)+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*)
*:(?:(?:\r\n)?[ \t])*)?(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+
|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r
\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:
\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t
]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031
]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](
?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?
:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?
:\r\n)?[ \t])*))*\>(?:(?:\r\n)?[ \t])*)|(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?
:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?
[ \t]))*"(?:(?:\r\n)?[ \t])*)*:(?:(?:\r\n)?[ \t])*(?:(?:(?:[^()<>@,;:\\".\[\]
\000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|
\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>
@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"
(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t]
)*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\
".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?
:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[
\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*|(?:[^()<>@,;:\\".\[\] \000-
\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(
?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)*\<(?:(?:\r\n)?[ \t])*(?:@(?:[^()<>@,;
:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([
^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\"
.\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\
]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*(?:,@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\
[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\
r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\]
\000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]
|\\.)*\](?:(?:\r\n)?[ \t])*))*)*:(?:(?:\r\n)?[ \t])*)?(?:[^()<>@,;:\\".\[\] \0
00-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\
.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,
;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?
:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*
(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".
\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[
^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]
]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*\>(?:(?:\r\n)?[ \t])*)(?:,\s*(
?:(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\
".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(
?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[
\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t
])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t
])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?
:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|
\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*|(?:
[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\
]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)*\<(?:(?:\r\n)
?[ \t])*(?:@(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["
()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)
?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>
@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*(?:,@(?:(?:\r\n)?[
\t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,
;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t]
)*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\
".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*)*:(?:(?:\r\n)?[ \t])*)?
(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".
\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:
\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[
"()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])
*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])
+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\
.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z
|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*\>(?:(
?:\r\n)?[ \t])*))*)?;\s*)
http://www.hwupgrade.org/public/style_emoticons/default/coolface.png
http://www.ex-parrot.com/pdw/Mail-RFC822-Address.html ;)
(?:(?:\r\n)?[ \t])*(?:(?:(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t]
)+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:
\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(
?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[
\t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\0
31]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\
](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+
(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:
(?:\r\n)?[ \t])*))*|(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z
|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)
?[ \t])*)*\<(?:(?:\r\n)?[ \t])*(?:@(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\
r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[
\t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)
?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t]
)*))*(?:,@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[
\t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*
)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t]
)+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*)
*:(?:(?:\r\n)?[ \t])*)?(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+
|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r
\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:
\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t
]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031
]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](
?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?
:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?
:\r\n)?[ \t])*))*\>(?:(?:\r\n)?[ \t])*)|(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?
:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?
[ \t]))*"(?:(?:\r\n)?[ \t])*)*:(?:(?:\r\n)?[ \t])*(?:(?:(?:[^()<>@,;:\\".\[\]
\000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|
\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>
@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"
(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t]
)*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\
".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?
:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[
\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*|(?:[^()<>@,;:\\".\[\] \000-
\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(
?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)*\<(?:(?:\r\n)?[ \t])*(?:@(?:[^()<>@,;
:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([
^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\"
.\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\
]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*(?:,@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\
[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\
r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\]
\000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]
|\\.)*\](?:(?:\r\n)?[ \t])*))*)*:(?:(?:\r\n)?[ \t])*)?(?:[^()<>@,;:\\".\[\] \0
00-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\
.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,
;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?
:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*
(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".
\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[
^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]
]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*\>(?:(?:\r\n)?[ \t])*)(?:,\s*(
?:(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\
".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(
?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[
\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t
])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t
])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?
:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|
\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*|(?:
[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\
]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)*\<(?:(?:\r\n)
?[ \t])*(?:@(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["
()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)
?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>
@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*(?:,@(?:(?:\r\n)?[
\t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,
;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t]
)*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\
".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*)*:(?:(?:\r\n)?[ \t])*)?
(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".
\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:
\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[
"()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])
*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])
+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\
.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z
|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*\>(?:(
?:\r\n)?[ \t])*))*)?;\s*)
http://www.hwupgrade.org/public/style_emoticons/default/coolface.png
http://www.ex-parrot.com/pdw/Mail-RFC822-Address.html ;)
The_ouroboros
04-02-2013, 18:52
invoco il diritto a rimanere il silenzio:cool:
sottovento
05-02-2013, 08:56
questa, per esempio, che cosa fa?
<cut>
http://www.ex-parrot.com/pdw/Mail-RFC822-Address.html ;)
Ok, ma non credo che un programma di traduzione automatica in italiano possa aiutare granche' a capire questa regexpr, in ogni caso.
<cut>
http://www.ex-parrot.com/pdw/Mail-RFC822-Address.html ;)
Ok, ma non credo che un programma di traduzione automatica in italiano possa aiutare granche' a capire questa regexpr, in ogni caso.
Vincenzo1968
05-02-2013, 10:37
Ok, ma non credo che un programma di traduzione automatica in italiano possa aiutare granche' a capire questa regexpr, in ogni caso.
Dici?
Una volta che te la spezzetta e per ogni pezzo ti scrive una riga con la spiegazione?
Per esempio:
[sottoespressione1: "subregexp1"]: questa parte trova le parole che cominciano per 'p'
[sottoespressione2: "subregexp2"]: le parole inoltre debbono contenere una tra le seguenti lettere: 'a', 'r', 'z'
...
...
...
Io dico che facilita la vita, e molto. ;)
Dici?
Una volta che te la spezzetta e per ogni pezzo ti scrive una riga con la spiegazione?
Per esempio:
[sottoespressione1: "subregexp1"]: questa parte trova le parole che cominciano per 'p'
[sottoespressione2: "subregexp2"]: le parole inoltre debbono contenere una tra le seguenti lettere: 'a', 'r', 'z'
...
...
...
Io dico che facilita la vita, e molto. ;)
sottovento
05-02-2013, 11:33
Dici?
Una volta che te la spezzetta e per ogni pezzo ti scrive una riga con la spiegazione?
Per esempio:
[sottoespressione1: "subregexp1"]: questa parte trova le parole che cominciano per 'p'
[sottoespressione2: "subregexp2"]: le parole inoltre debbono contenere una tra le seguenti lettere: 'a', 'r', 'z'
...
...
...
Io dico che facilita la vita, e molto. ;)
Spezzetta arbitrariamente? In regexp non esiste il concetto di "pezzo" :D
Se cosi' e', la traduzione potrebbe essere anche piu' difficile della regexp di partenza.
Cmq non e' mai detto, magari esce qualcosa di carino. Io sono dubbioso, ma lo sono per natura
Una volta che te la spezzetta e per ogni pezzo ti scrive una riga con la spiegazione?
Per esempio:
[sottoespressione1: "subregexp1"]: questa parte trova le parole che cominciano per 'p'
[sottoespressione2: "subregexp2"]: le parole inoltre debbono contenere una tra le seguenti lettere: 'a', 'r', 'z'
...
...
...
Io dico che facilita la vita, e molto. ;)
Spezzetta arbitrariamente? In regexp non esiste il concetto di "pezzo" :D
Se cosi' e', la traduzione potrebbe essere anche piu' difficile della regexp di partenza.
Cmq non e' mai detto, magari esce qualcosa di carino. Io sono dubbioso, ma lo sono per natura
Vincenzo1968
05-02-2013, 11:37
Spezzetta arbitrariamente? In regexp non esiste il concetto di "pezzo" :D
Se cosi' e', la traduzione potrebbe essere anche piu' difficile della regexp di partenza.
Cmq non e' mai detto, magari esce qualcosa di carino. Io sono dubbioso, ma lo sono per natura
Spezzetta nel senso che la suddivide nelle varie sottoespressioni in cui è composta una regexp.
Non ci vuole niente, avendo a disposizione la grammatica BNF per le regexp, a creare un programmino del genere.
Per la grammatica si possono vedere i sorgenti di grep o egrep: c'è la grammatica in formato Bison!
In sostanza, a ogni produzione della grammatica, noi facciamo corrispondere la frase con la spiegazione in italiano anziché creare il ramo dell'automa come fanno grep e egrep.
:yeah: :winner: :yeah:
Se cosi' e', la traduzione potrebbe essere anche piu' difficile della regexp di partenza.
Cmq non e' mai detto, magari esce qualcosa di carino. Io sono dubbioso, ma lo sono per natura
Spezzetta nel senso che la suddivide nelle varie sottoespressioni in cui è composta una regexp.
Non ci vuole niente, avendo a disposizione la grammatica BNF per le regexp, a creare un programmino del genere.
Per la grammatica si possono vedere i sorgenti di grep o egrep: c'è la grammatica in formato Bison!
In sostanza, a ogni produzione della grammatica, noi facciamo corrispondere la frase con la spiegazione in italiano anziché creare il ramo dell'automa come fanno grep e egrep.
:yeah: :winner: :yeah:
The_ouroboros
05-02-2013, 12:15
mmmm.... interessante.
Posso chiederti se apri un 3d o mi mandi un pv con maggiori info su parser/grammatiche?
Sembgra un argomento interessante...
Posso chiederti se apri un 3d o mi mandi un pv con maggiori info su parser/grammatiche?
Sembgra un argomento interessante...
Vincenzo1968
05-02-2013, 12:17
mmmm.... interessante.
Posso chiederti se apri un 3d o mi mandi un pv con maggiori info su parser/grammatiche?
Sembra un argomento interessante...
Minchia, se è interessante. Eccome se è interessante. Anche se in molti qui dicono di no... :D
Più tardi ti mando tutto quello che occorre via pvt. Il tempo di raccogliere tutta la documentazione ;)
Intanto dai un'occhiata alla documentazione di Flex e Bison. ;)
http://www.gnu.org/software/bison/
http://www.gnu.org/software/flex/
flex.sourceforge.net
Posso chiederti se apri un 3d o mi mandi un pv con maggiori info su parser/grammatiche?
Sembra un argomento interessante...
Minchia, se è interessante. Eccome se è interessante. Anche se in molti qui dicono di no... :D
Più tardi ti mando tutto quello che occorre via pvt. Il tempo di raccogliere tutta la documentazione ;)
Intanto dai un'occhiata alla documentazione di Flex e Bison. ;)
http://www.gnu.org/software/bison/
http://www.gnu.org/software/flex/
flex.sourceforge.net
The_ouroboros
05-02-2013, 12:19
potessi...
Giorni di fuego in ufficio per il Canvass di Febbraio di Voda..:D
Giorni di fuego in ufficio per il Canvass di Febbraio di Voda..:D
Vincenzo1968
05-02-2013, 12:21
potessi...
Giorni di fuego in ufficio per il Canvass di Febbraio di Voda..:D
Comunque si, aprirò un thread dedicato: il prossimo contest sarà dedicato a questo. :D
Giorni di fuego in ufficio per il Canvass di Febbraio di Voda..:D
Comunque si, aprirò un thread dedicato: il prossimo contest sarà dedicato a questo. :D
clockover
05-02-2013, 18:31
:1,$s/[A-Z][a-z]*/Signor &/g
cosa vuol dire :1,$ misà che mi è sfuggito qualcosa :confused:
cosa vuol dire :1,$ misà che mi è sfuggito qualcosa :confused:
The_ouroboros
05-02-2013, 18:42
cosa vuol dire misà che mi è sfuggito qualcosa :confused:
:1,$
Vuol dire da inizio (1) a fine ($) riga.
:1,$s/[A-Z][a-z]*/Signor &/g
sostituisci i nomi (prima lettera maiuscola seguida da 0 o più(*) lettere minuscole) con Signor seguito dal nome trovato ( & ) .
Il g lo estende a tutto il file.
:1,$
Vuol dire da inizio (1) a fine ($) riga.
:1,$s/[A-Z][a-z]*/Signor &/g
sostituisci i nomi (prima lettera maiuscola seguida da 0 o più(*) lettere minuscole) con Signor seguito dal nome trovato ( & ) .
Il g lo estende a tutto il file.
sottovento
05-02-2013, 18:47
cosa vuol dire misà che mi è sfuggito qualcosa :confused:
E' un modo di indicare un intervallo di linee sulle quali il comando dovra' agire.
Il comando agira' quindi dalla linea 1 alla linea $ (che significa ultima).
Ci sono anche altri modi di definire l'intervallo.
Per esempio, dalla linea corrente (indicata con il punto) oppure marcando una linea mediante comando m.
Se per esempio vuoi impartire un comando dalla linea attuale a quella che hai marcato posizionandotici sopra e digitando ma, scriverai:
:.,'a
E' un modo di indicare un intervallo di linee sulle quali il comando dovra' agire.
Il comando agira' quindi dalla linea 1 alla linea $ (che significa ultima).
Ci sono anche altri modi di definire l'intervallo.
Per esempio, dalla linea corrente (indicata con il punto) oppure marcando una linea mediante comando m.
Se per esempio vuoi impartire un comando dalla linea attuale a quella che hai marcato posizionandotici sopra e digitando ma, scriverai:
:.,'a
sottovento
05-02-2013, 18:49
:1,$
Vuol dire da inizio (1) a fine ($) riga.
:1,$s/[A-Z][a-z]*/Signor &/g
sostituisci i nomi (prima lettera maiuscola seguida da 0 o più(*) lettere minuscole) con Signor seguito dal nome trovato ( & ) .
Il g lo estende a tutto il file.
Attenzione - g non estende a tutto il file, bensi estende la sostituzione a tutti i pattern trovati su di una linea!
In pratica, se non dai g effettuera' la sostituzione della prima ricorrenza di quella linea, e non tocchera' le successive. (puo' essere comodo, soprattutto quando si decide di lavorare con file .csv).
Vuol dire da inizio (1) a fine ($) riga.
:1,$s/[A-Z][a-z]*/Signor &/g
sostituisci i nomi (prima lettera maiuscola seguida da 0 o più(*) lettere minuscole) con Signor seguito dal nome trovato ( & ) .
Il g lo estende a tutto il file.
Attenzione - g non estende a tutto il file, bensi estende la sostituzione a tutti i pattern trovati su di una linea!
In pratica, se non dai g effettuera' la sostituzione della prima ricorrenza di quella linea, e non tocchera' le successive. (puo' essere comodo, soprattutto quando si decide di lavorare con file .csv).
clockover
05-02-2013, 18:58
Il comando agira' quindi dalla linea 1 alla linea $ (che significa ultima).
A ok infatti mi aveva confuso un po questo Vuol dire da inizio (1) a fine ($) riga
Molto interessante questo thread
A ok infatti mi aveva confuso un po questo Vuol dire da inizio (1) a fine ($) riga
Molto interessante questo thread
The_ouroboros
05-02-2013, 19:22
Attenzione - g non estende a tutto il file, bensi estende la sostituzione a tutti i pattern trovati su di una linea!
In pratica, se non dai g effettuera' la sostituzione della prima ricorrenza di quella linea, e non tocchera' le successive. (puo' essere comodo, soprattutto quando si decide di lavorare con file .csv).
sorry 9 ore e mezza di pieno canvas mi rendono un poco stanco :doh:
In pratica, se non dai g effettuera' la sostituzione della prima ricorrenza di quella linea, e non tocchera' le successive. (puo' essere comodo, soprattutto quando si decide di lavorare con file .csv).
sorry 9 ore e mezza di pieno canvas mi rendono un poco stanco :doh:
sottovento
06-02-2013, 06:17
sorry 9 ore e mezza di pieno canvas mi rendono un poco stanco :doh:
Non c'e' bisogno di scusarsi per cosi' poco.
Ad ogni modo, volevo riportare una curiosita': sui vecchi sistemi unix esisteva una shell chiamata ksh (Korn Shell).
Questa poteva essere configurata in modo da usare l'editor vi (a livello di linea singola) come prompt!! Cio' significava che al prompt si poteva premere ESC e spostarsi lungo i comandi impartiti (nella history, per intenderci) con tutti i comandi standard di vi, editare il comando, fare ricerche e cosi' via.
Poi la ksh e' stata abbandonata, e non l'ho mai vista sui sistemi linux.
Qualcuno che usa linux e' piu' informato? Esiste una versione linuxara di ksh, magari scaricabile?
Non c'e' bisogno di scusarsi per cosi' poco.
Ad ogni modo, volevo riportare una curiosita': sui vecchi sistemi unix esisteva una shell chiamata ksh (Korn Shell).
Questa poteva essere configurata in modo da usare l'editor vi (a livello di linea singola) come prompt!! Cio' significava che al prompt si poteva premere ESC e spostarsi lungo i comandi impartiti (nella history, per intenderci) con tutti i comandi standard di vi, editare il comando, fare ricerche e cosi' via.
Poi la ksh e' stata abbandonata, e non l'ho mai vista sui sistemi linux.
Qualcuno che usa linux e' piu' informato? Esiste una versione linuxara di ksh, magari scaricabile?
The_ouroboros
06-02-2013, 06:39
La bash supporta la modalità vi
(l'attuale e emacs mode) e ksh esiste ancora..la uso su freebsd.
Inviato dal mio LT22i con Tapatalk 2
(l'attuale e emacs mode) e ksh esiste ancora..la uso su freebsd.
Inviato dal mio LT22i con Tapatalk 2
The_ouroboros
06-02-2013, 06:40
http://linux.die.net/man/1/ksh
http://www.linuxquestions.org/questions/linux-newbie-8/how-to-install-ksh-shell-285733/
Inviato dal mio LT22i con Tapatalk 2
http://www.linuxquestions.org/questions/linux-newbie-8/how-to-install-ksh-shell-285733/
Inviato dal mio LT22i con Tapatalk 2
sottovento
06-02-2013, 06:51
Grazie a The_ouroboros per la precisazione. Ottimo!!
Volevo aggiungere qualcosa sul comando gd: durante la scrittura di un'applicazione ci si puo' posizionare su una variabile e impartire il comando gd.
Questo dovrebbe spostare il cursore sulla DICHIARAZIONE della variabile in oggetto.
Purtroppo non e' sempre vero, soprattutto se usate lo stesso nome di variabile locale in diverse funzioni
Volevo aggiungere qualcosa sul comando gd: durante la scrittura di un'applicazione ci si puo' posizionare su una variabile e impartire il comando gd.
Questo dovrebbe spostare il cursore sulla DICHIARAZIONE della variabile in oggetto.
Purtroppo non e' sempre vero, soprattutto se usate lo stesso nome di variabile locale in diverse funzioni
The_ouroboros
06-02-2013, 06:53
Questo non lo conoscevo... Thanks :D
Inviato dal mio LT22i con Tapatalk 2
Inviato dal mio LT22i con Tapatalk 2
Vincenzo1968
06-02-2013, 12:32
Una domanda un po' ot ma la faccio qui a voi che ve ne intendete del mondo Linux.
Se uno volesse proporre un proprio programmino da distribuire insieme alle altre utility nelle varie distro Linux, cosa dovrebbe fare?
Non dico per il programmino di traduzione delle regexp in italiano/inglese, dico in generale.
C'è un qualche link dove proporre il proprio programma? O si mette online, su un sito, e poi la comunità Linux decide se includerlo nelle varie distro? Come funziona?
Se uno volesse proporre un proprio programmino da distribuire insieme alle altre utility nelle varie distro Linux, cosa dovrebbe fare?
Non dico per il programmino di traduzione delle regexp in italiano/inglese, dico in generale.
C'è un qualche link dove proporre il proprio programma? O si mette online, su un sito, e poi la comunità Linux decide se includerlo nelle varie distro? Come funziona?
sottovento
07-02-2013, 04:34
Vincenzo, scusa non ti sto ignorando, e' che non ho la risposta alla tua domanda ma volevo rendere edotta la comunita' di qualche altro simpatico comando di vim.
Volevo infatti parlare dello switch maiuscolo/minuscolo.
Per cambiare il case di un carattere (da maiuscolo a minuscolo e viceversa) si puo' usare il comando ~, il quale cambiera' il carattere sotto il cursore.
Come sempre, lo si puo' far precedere da un valore numerico:
10~
Cambiera' da maiuscolo a minuscolo (e viceversa) i prossimi 10 caratteri a partire da quello sotto il cursore.
Cmq vim sa anche fare di meglio:
Vu
rende tutta la linea minuscola
VU
rende tutta la linea maiuscola
g~~
cambia tutti i caratteri della linea da maiuscolo a minuscolo e viceversa
vEU
la parola sotto il cursore diventa maiuscola (fino al primo spazio)
Per cambiare l'intero testo in minuscolo, basta andare sulla prima linea e digitare
guG
ovviamente
gUG
rende tutto maiuscolo
Volevo infatti parlare dello switch maiuscolo/minuscolo.
Per cambiare il case di un carattere (da maiuscolo a minuscolo e viceversa) si puo' usare il comando ~, il quale cambiera' il carattere sotto il cursore.
Come sempre, lo si puo' far precedere da un valore numerico:
10~
Cambiera' da maiuscolo a minuscolo (e viceversa) i prossimi 10 caratteri a partire da quello sotto il cursore.
Cmq vim sa anche fare di meglio:
Vu
rende tutta la linea minuscola
VU
rende tutta la linea maiuscola
g~~
cambia tutti i caratteri della linea da maiuscolo a minuscolo e viceversa
vEU
la parola sotto il cursore diventa maiuscola (fino al primo spazio)
Per cambiare l'intero testo in minuscolo, basta andare sulla prima linea e digitare
guG
ovviamente
gUG
rende tutto maiuscolo
sottovento
07-02-2013, 04:45
La gestione maiuscolo/minuscolo puo' essere fatta anche per quanto riguarda le ricerche e le sostituzioni.
Per default, la ricerca sotto vim e' case-sensitive.
Si puo' modificare questo comportamento mediante
:se ignorecase
da questo momento in poi, le ricerche/sostituzioni non faranno piu' distinzione fra maiuscole e minuscole.
Volendo tornare indietro:
:se noignorecase
Qualche sostituzione notevole:
:1,$s/\<./\u&/g
rende maiuscola la prima lettera di ogni parola nel testo assegnato (nel mio esempio, su tutto il file)
Analogamente:
:1,$s/\<./\l&/g
la prima lettera di ogni parola diventera' minuscola
:1,$s/^.*/\u&
la prima lettera di ogni RIGA diventera' maiuscola
:1,$s/^.*/\l&
la prima lettera di ogni RIGA diventera' minuscola.
Nota sulle ultime due sostituzioni: e' mia abitudine inserire anche il simbolo ^ per specificare che dobbiamo partire ad inizio linea. E' pero' evidente che in questo caso le sostituzioni avrebbero funzionato lo stesso, anche senza di lui. Mi scuso per la ridondanza dovuta all'abitudine
Nota sull'intervallo: come sempre, metto l'intervallo 1,$. Tale intervallo puo' anche essere rappresentato semplicemente dal simbolo %, pertanto le due sostituzioni
:1,$s/^.*/\l&
:%s/^.*/\l&
sono uguali. Forza dell'abitudine. Chiedo scusa
Per default, la ricerca sotto vim e' case-sensitive.
Si puo' modificare questo comportamento mediante
:se ignorecase
da questo momento in poi, le ricerche/sostituzioni non faranno piu' distinzione fra maiuscole e minuscole.
Volendo tornare indietro:
:se noignorecase
Qualche sostituzione notevole:
:1,$s/\<./\u&/g
rende maiuscola la prima lettera di ogni parola nel testo assegnato (nel mio esempio, su tutto il file)
Analogamente:
:1,$s/\<./\l&/g
la prima lettera di ogni parola diventera' minuscola
:1,$s/^.*/\u&
la prima lettera di ogni RIGA diventera' maiuscola
:1,$s/^.*/\l&
la prima lettera di ogni RIGA diventera' minuscola.
Nota sulle ultime due sostituzioni: e' mia abitudine inserire anche il simbolo ^ per specificare che dobbiamo partire ad inizio linea. E' pero' evidente che in questo caso le sostituzioni avrebbero funzionato lo stesso, anche senza di lui. Mi scuso per la ridondanza dovuta all'abitudine
Nota sull'intervallo: come sempre, metto l'intervallo 1,$. Tale intervallo puo' anche essere rappresentato semplicemente dal simbolo %, pertanto le due sostituzioni
:1,$s/^.*/\l&
:%s/^.*/\l&
sono uguali. Forza dell'abitudine. Chiedo scusa
clockover
07-02-2013, 19:50
Supponiamo che copio in un buffer una linea con "aY, poi in un altro con "bY e così per tanti altri.
Adesso non mi ricordo più niente, ho memorizzato così tanti buffer che ormai non me li ricordo più. C'è un modo per avere non so un riepilogo di tutto quello memorizzato?
E due, aspetto info sul recording di Vim :D
Adesso non mi ricordo più niente, ho memorizzato così tanti buffer che ormai non me li ricordo più. C'è un modo per avere non so un riepilogo di tutto quello memorizzato?
E due, aspetto info sul recording di Vim :D
sottovento
08-02-2013, 04:08
Supponiamo che copio in un buffer una linea con "aY, poi in un altro con "bY e così per tanti altri.
Adesso non mi ricordo più niente, ho memorizzato così tanti buffer che ormai non me li ricordo più. C'è un modo per avere non so un riepilogo di tutto quello memorizzato?
E due, aspetto info sul recording di Vim :D
Per quanto ne so non c'e' un modo specifico per vedere cosa c'e' nel buffer.
Io semplicemente lo incollo, vedo e premo u.
Quindi: "ap e poi u. Tutto sommato vim e' piuttosto bravo in questo che mi sembra non ci sia bisogno d'altro.
Sul recording non so assolutamente nulla, mi spiace :cry:
Adesso non mi ricordo più niente, ho memorizzato così tanti buffer che ormai non me li ricordo più. C'è un modo per avere non so un riepilogo di tutto quello memorizzato?
E due, aspetto info sul recording di Vim :D
Per quanto ne so non c'e' un modo specifico per vedere cosa c'e' nel buffer.
Io semplicemente lo incollo, vedo e premo u.
Quindi: "ap e poi u. Tutto sommato vim e' piuttosto bravo in questo che mi sembra non ci sia bisogno d'altro.
Sul recording non so assolutamente nulla, mi spiace :cry:
The_ouroboros
08-02-2013, 07:08
Non ne conosco nemmeno io.. :(
Inviato dal mio LT22i con Tapatalk 2
Inviato dal mio LT22i con Tapatalk 2
clockover
08-02-2013, 14:07
Ne butto giù una anche io :D ... siete stufi di vedere evidenziata l'ultima ricerca??? Avete evidenziato tutto il testo e non volete riuscite a capire più una mazza??? Nessun problema... ora c'è :noh :sofico:
clockover
08-02-2013, 19:07
In merito al post di sottovento sui buffers vorrei aggiungere qualcosa.
Scrivendo "aYsalviamo nel buffer a una linea
Se vogliamo aggiungere qualcosa a quel buffer possiamo farlo. Ci portiamo sulla linea che vogliamo aggiungere a quel buffer e scriviamo "AY
Quindi per aggiungere nel buffer basta utilizzare la stessa variabile in maiuscolo
Scrivendo "aYsalviamo nel buffer a una linea
Se vogliamo aggiungere qualcosa a quel buffer possiamo farlo. Ci portiamo sulla linea che vogliamo aggiungere a quel buffer e scriviamo "AY
Quindi per aggiungere nel buffer basta utilizzare la stessa variabile in maiuscolo
clockover
08-02-2013, 19:31
Supponiamo che copio in un buffer una linea con "aY, poi in un altro con "bY e così per tanti altri.
Adesso non mi ricordo più niente, ho memorizzato così tanti buffer che ormai non me li ricordo più. C'è un modo per avere non so un riepilogo di tutto quello memorizzato?
E allora mi rispondo da solo :D è mai possibile che Vim non abbia pensato a questo??
Basta scrivere:rege abbiamo un resoconto di tutti i registri messi a disposizione da Vim
Adesso non mi ricordo più niente, ho memorizzato così tanti buffer che ormai non me li ricordo più. C'è un modo per avere non so un riepilogo di tutto quello memorizzato?
E allora mi rispondo da solo :D è mai possibile che Vim non abbia pensato a questo??
Basta scrivere:rege abbiamo un resoconto di tutti i registri messi a disposizione da Vim
The_ouroboros
09-02-2013, 09:27
aggiungo che qui (http://www.vim.org/sponsor/index.php) è possibile aiutare lo sviluppo di vim e anche un po una buona causa donando quanto si può/riesce.
Vincenzo1968
09-02-2013, 09:54
Lo sapevate che, nella shell Bourne, se comincio a scrivere il nome di un file e premo tab, mi fa il completamento automatico?
http://img811.imageshack.us/img811/8546/losapevateche.jpg
È una minchiatella ma io non lo sapevo e l'ho scoperto per caso(m'è scivolato il dito sul tasto tab quando avevo scritto "gcc -O3 punto".
:yeah: :winner: :yeah:
http://img811.imageshack.us/img811/8546/losapevateche.jpg
È una minchiatella ma io non lo sapevo e l'ho scoperto per caso(m'è scivolato il dito sul tasto tab quando avevo scritto "gcc -O3 punto".
:yeah: :winner: :yeah:
The_ouroboros
09-02-2013, 10:15
Lo sapevate che, nella shell Bourne, se comincio a scrivere il nome di un file e premo tab, mi fa il completamento automatico?
http://img811.imageshack.us/img811/8546/losapevateche.jpg
È una minchiatella ma io non lo sapevo e l'ho scoperto per caso(m'è scivolato il dito sul tasto tab quando avevo scritto "gcc -O3 punto".
:yeah: :winner: :yeah:
Lo uso da così tanto che quasi non ci penso più... :stordita:
http://img811.imageshack.us/img811/8546/losapevateche.jpg
È una minchiatella ma io non lo sapevo e l'ho scoperto per caso(m'è scivolato il dito sul tasto tab quando avevo scritto "gcc -O3 punto".
:yeah: :winner: :yeah:
Lo uso da così tanto che quasi non ci penso più... :stordita:
Vincenzo1968
09-02-2013, 10:37
Eh ma per me, niubbo, è stata una piacevolissima sorpresa. Bella e utile: con quei nomi di file chilometrici...
:D
P.S.: non m'è proprio "scivolato" il dito. Mi stava cadendo il caffé e mi sono appoggiato con la sinistra alla tastiera. Poi dice che la caffeina fa male... :D
:D
P.S.: non m'è proprio "scivolato" il dito. Mi stava cadendo il caffé e mi sono appoggiato con la sinistra alla tastiera. Poi dice che la caffeina fa male... :D
The_ouroboros
09-02-2013, 10:48
A volte basta buona guida per la Bash (http://www.amazon.it/gp/product/0596009658/ref=oh_details_o04_s00_i00) per scoprire cose che magari non immaginavi fattibili in poco + di poche righe. :D
P.S se proprio cercate qualcosa di scritto su vi e vim .... Learning the vi and Vim Editors (http://www.amazon.it/Learning-Vim-Editors-Arnold-Robbins/dp/059652983X/ref=pd_sim_eb_1). Anche se l'online basta.
P.p.s: lo so che sembro molto orientato alla Oreilly ma i loro livri li ho sempre trovati ottimi :cool:
P.S se proprio cercate qualcosa di scritto su vi e vim .... Learning the vi and Vim Editors (http://www.amazon.it/Learning-Vim-Editors-Arnold-Robbins/dp/059652983X/ref=pd_sim_eb_1). Anche se l'online basta.
P.p.s: lo so che sembro molto orientato alla Oreilly ma i loro livri li ho sempre trovati ottimi :cool:
clockover
10-02-2013, 09:45
Lo sapevate che, nella shell Bourne, se comincio a scrivere il nome di un file e premo tab, mi fa il completamento automatico?
http://img811.imageshack.us/img811/8546/losapevateche.jpg
È una minchiatella ma io non lo sapevo e l'ho scoperto per caso(m'è scivolato il dito sul tasto tab quando avevo scritto "gcc -O3 punto".
:yeah: :winner: :yeah:
La conoscenza di questa shortcut è praticamente obbligatoria. Tra l'altro anche nel mondo Windows funziona :) Visto che ci sei ti faccio notare anche che se ci sono più files che cominciano in modo simile, premendo TAB ti vengono mostrate tutte le possibilità.
Ho trovato un altro documento su Vim --> http://ivan.tubert.org/doc/vimbook.pdf
http://img811.imageshack.us/img811/8546/losapevateche.jpg
È una minchiatella ma io non lo sapevo e l'ho scoperto per caso(m'è scivolato il dito sul tasto tab quando avevo scritto "gcc -O3 punto".
:yeah: :winner: :yeah:
La conoscenza di questa shortcut è praticamente obbligatoria. Tra l'altro anche nel mondo Windows funziona :) Visto che ci sei ti faccio notare anche che se ci sono più files che cominciano in modo simile, premendo TAB ti vengono mostrate tutte le possibilità.
Ho trovato un altro documento su Vim --> http://ivan.tubert.org/doc/vimbook.pdf
Vincenzo1968
10-02-2013, 11:07
La conoscenza di questa shortcut è praticamente obbligatoria. Tra l'altro anche nel mondo Windows funziona :) Visto che ci sei ti faccio notare anche che se ci sono più files che cominciano in modo simile, premendo TAB ti vengono mostrate tutte le possibilità.
Ho trovato un altro documento su Vim --> http://ivan.tubert.org/doc/vimbook.pdf
Si, ho fatto qualche esperimento su Windows e mi sono accorto che c'è anche li. Dopo vent'anni... Ci voleva una tazzina di caffé. :D
Ho trovato un altro documento su Vim --> http://ivan.tubert.org/doc/vimbook.pdf
Si, ho fatto qualche esperimento su Windows e mi sono accorto che c'è anche li. Dopo vent'anni... Ci voleva una tazzina di caffé. :D
The_ouroboros
10-02-2013, 11:19
Si, ho fatto qualche esperimento su Windows e mi sono accorto che c'è anche li. Dopo vent'anni... Ci voleva una tazzina di caffé. :D
le migliori scoperte avvengono per strani eventi... :D
le migliori scoperte avvengono per strani eventi... :D
sottovento
11-02-2013, 04:21
E allora mi rispondo da solo :D è mai possibile che Vim non abbia pensato a questo??
Basta scrivere:rege abbiamo un resoconto di tutti i registri messi a disposizione da Vim
Bello, non lo conoscevo. Inoltre mostra anche registri di cui ignoravo l'esistenza.
Visto che ci siamo: il comando :r permette di leggere un file e di inserirne il testo nella posizione corrente, per esempio:
:r ciao.txt
Il testo di ciao.txt verra' inserito sotto il cursore.
E' interessante notare che si puo' inserire alla stessa maniera l'output di comandi, per esempio:
:r !dir
(ovviamente sotto Windows) inserira' nella posizione corrente l'output del comando dir.
Basta scrivere:rege abbiamo un resoconto di tutti i registri messi a disposizione da Vim
Bello, non lo conoscevo. Inoltre mostra anche registri di cui ignoravo l'esistenza.
Visto che ci siamo: il comando :r permette di leggere un file e di inserirne il testo nella posizione corrente, per esempio:
:r ciao.txt
Il testo di ciao.txt verra' inserito sotto il cursore.
E' interessante notare che si puo' inserire alla stessa maniera l'output di comandi, per esempio:
:r !dir
(ovviamente sotto Windows) inserira' nella posizione corrente l'output del comando dir.
clockover
14-02-2013, 09:52
Un tutorial sulle espressioni regolari utilizzabili in Vim --> http://vimregex.com/
sottovento
20-02-2013, 08:31
Riprendo questo thread per indicare qualche replace che potrebbe risultare utile.
Se per esempio abbiamo una lista di variabili, del tipo:
int var1
char var2
String mystring
e queste sono in gran numero, generare i corrisponenti accessor (getters/setters) puo' essere tedioso.
Molti ide hanno la corrispondente opzione. In vi basta scrivere:
:.,'ms/\(^[^ ]*\) \([^ ]*\)/public \1 get\2() { return \2; }/
per generare i getters, e
:.,'ms/\(^[^ ]*\) \([^ ]*\)/public void set\2(\1 \2) { this.\2 = \2; }/
per i setters.
Volevo pubblicare queste sostituzioni per evidenziare come l'espressione regolare che si va a cercare puo' essere spezzata mediante l'uso delle parentesi tonde (che devono essere precedute dal backslash).
Questo fa in modo che le singole parti di quanto trovato possano essere poi referenziate in fase di sostituzione mediante \1, \2 e cosi' via.
Se per esempio abbiamo una lista di variabili, del tipo:
int var1
char var2
String mystring
e queste sono in gran numero, generare i corrisponenti accessor (getters/setters) puo' essere tedioso.
Molti ide hanno la corrispondente opzione. In vi basta scrivere:
:.,'ms/\(^[^ ]*\) \([^ ]*\)/public \1 get\2() { return \2; }/
per generare i getters, e
:.,'ms/\(^[^ ]*\) \([^ ]*\)/public void set\2(\1 \2) { this.\2 = \2; }/
per i setters.
Volevo pubblicare queste sostituzioni per evidenziare come l'espressione regolare che si va a cercare puo' essere spezzata mediante l'uso delle parentesi tonde (che devono essere precedute dal backslash).
Questo fa in modo che le singole parti di quanto trovato possano essere poi referenziate in fase di sostituzione mediante \1, \2 e cosi' via.
Vincenzo1968
20-02-2013, 14:10
aggiungo che qui (http://www.vim.org/sponsor/index.php) è possibile aiutare lo sviluppo di vim e anche un po una buona causa donando quanto si può/riesce.
Eh ma i sorgenti sono in C. :cry:
Eh ma i sorgenti sono in C. :cry:
The_ouroboros
21-02-2013, 17:02
io intendevo aiutino in dinero(gia fatto) :D
E cmq sono in C perchè molti della FSF sono talebani del code e il C++ lo snobbano ;)
E cmq sono in C perchè molti della FSF sono talebani del code e il C++ lo snobbano ;)
The_ouroboros
21-02-2013, 17:07
versione ufficiale vim per Win32/64 (http://www.vim.org/download.php#pc)
http://img715.imageshack.us/img715/9985/gvim.jpg (http://imageshack.us/photo/my-images/715/gvim.jpg/)
Uploaded with ImageShack.us (http://imageshack.us)
http://img715.imageshack.us/img715/9985/gvim.jpg (http://imageshack.us/photo/my-images/715/gvim.jpg/)
Uploaded with ImageShack.us (http://imageshack.us)
Vincenzo1968
21-02-2013, 17:17
io intendevo aiutino in dinero(gia fatto) :D
E cmq sono in C perchè molti della FSF sono talebani del code e il C++ lo snobbano ;)
Ah pure io ho provveduto finanziariamente.
Comunque un fottìo di progetti su Linux sono in C. 'Sti talebani... :rolleyes:
:D
E cmq sono in C perchè molti della FSF sono talebani del code e il C++ lo snobbano ;)
Ah pure io ho provveduto finanziariamente.
Comunque un fottìo di progetti su Linux sono in C. 'Sti talebani... :rolleyes:
:D
The_ouroboros
21-02-2013, 17:32
Ah pure io ho provveduto finanziariamente.
Comunque un fottìo di progetti su Linux sono in C. 'Sti talebani... :rolleyes:
:D
sono scelte, condivisibili o meno.
L'unica cosa è che a volte, come in Vi...nato qualche 37 anni fa, il C++ non era una scelta molto attuabile o cmq dai "piani alti"( stallmann, linus),in seguiti con vim ad esempio, ben candidata :stordita:
Comunque un fottìo di progetti su Linux sono in C. 'Sti talebani... :rolleyes:
:D
sono scelte, condivisibili o meno.
L'unica cosa è che a volte, come in Vi...nato qualche 37 anni fa, il C++ non era una scelta molto attuabile o cmq dai "piani alti"( stallmann, linus),in seguiti con vim ad esempio, ben candidata :stordita:
Vincenzo1968
21-02-2013, 17:35
sono scelte, condivisibili o meno.
L'unica cosa è che a volte, come in Vi...nato qualche 37 anni fa, il C++ non era una scelta molto attuabile o cmq dai "piani alti"( stallmann, linus) ben candidata :stordita:
Ah si, la solita storia del codice da riscrivere. Già sentita mille volte. Ma, in questo caso, non stiamo parlando di un'applicazione enorme. Non parliamo di un sistema operativo. Non parliamo di un DBMS. Da 37 anni a questa parte potevano pensare a convertire il codice in C++, no?
L'unica cosa è che a volte, come in Vi...nato qualche 37 anni fa, il C++ non era una scelta molto attuabile o cmq dai "piani alti"( stallmann, linus) ben candidata :stordita:
Ah si, la solita storia del codice da riscrivere. Già sentita mille volte. Ma, in questo caso, non stiamo parlando di un'applicazione enorme. Non parliamo di un sistema operativo. Non parliamo di un DBMS. Da 37 anni a questa parte potevano pensare a convertire il codice in C++, no?
The_ouroboros
21-02-2013, 17:39
if it ain't broke, don't fix it (Cit.)
vBulletin® v3.6.4, Copyright ©2000-2025, Jelsoft Enterprises Ltd.