Newsgroup: it.comp.lang.perl
Titolo: Buffer di cattura e tester regexp

Ho un quesito da sottoporvi riguardo i buffer di cattura
Io ho due regexp consecutive con buffer di cattura
$core=~ m/\s*(\w*)\s*$/s;  
.
.
.
$core=~ m/\<([0-3][0-9],[0-1][0-9],[0-9]{4}.*)\>/s;  
.
In caso la seconda regexp non produca nessuna match mi risulta che il 
buffer $1 rimanga settato con il valore che ottengo dalla prima regexp.
Non esiste un modo di resettarlo visto che read-only? Come faccio a 
sapere se la seconda regexp ha prodotto un match o semplicemente è il 
valore della prima rimasto in $1?
Dovrei processare un messaggio del tipo
(! testo testo <22,11,2002-11:22>  password !)
ed estrarre la parte fra (! !), estraendo al contempo la data compresa in 
< > e l'ultima parola che è una password.
Per ora ho risolto accorpando il tutto in una sola regexp
$message=~ m/
                \(\! # inizio messaggio valido
                        (  # $1 buffer cattura messaggio
                        .* # qualsiasi cosa seguito da
                        (\<([0-3]?[0-9],[0-1]?[0-9],[0-9]{4}.*)\>){1}
    	    	    	    	   # data 1 volta
                        .* # altri caratteri arbitrari
                        \s+ #1 o più whitespaces
                           ( # $4 buffer di cattura password
                           \w* # un elenco di n caratteri alfanumerici
                           ) # fine buffer di cattura password $4
                        \s* #0 o più whitespaces
                        )#fine buffer di cattura messaggio $1
                \!\)# fine messaggio valido
                /sx;
Che dovrebbe darmi in $1 il messaggio, in $2 la data con le <>, in $3 la 
data senza <> e in $4 la password.
Ultima domanda: esiste qualche tool grafico win per testare le regexp?
Grazie dell'aiuto!

Ultima domanda: esiste qualche tool grafico win per testare le regexp?
Non credo. Non è tra l'altro chiarissimo che cosa intendi per "testare le
regexp". Verificare la correttezza sintattica? Provarle su un insieme di
dati?
In questo secondo caso, io trovo comodo metterle in un ciclo while(<DATA>)
{}, con dati simili a quelli di regime dopo __END__, e qualche istruzione
di print per vedere se mi salta effettivamente fuori quello che penso.
Ciao.

 esplicita:
   Anche il seguente idioma dovrebbe provvedere alla bisogna:
	{ $core=~ m/\s*(\w*)\s*$/s); use_or_misuse_of $1 }
	# here $1 does not lexically exist...
 
-- 
Alla prossima,
Marco

 insieme di dati?
Direi di si, comunque ce la si può cavare anche senza :)

      # here $1 does not lexically exist...
Grazie anche te, lo terrò presente per il futuro.

 sono restio a toccare le cose che funzionano. ;)
Come non detto, mi confermate che se i buffer non hanno un match le 
varibili "shiftano"?
Cioè se un buffer di cattura non è verificato la variabile $n relativa 
viene riusata dal buffer successivo?
In tal caso non può andar bene perchè la data è opzionale, se non c'è o non 
è nella forma prevista non so più in che buffer finisce...
dovrò usare uno dei vostri metodi.
Quindi vi ringrazio ancora! :)

 dati?
credi male, perché ricordo che ce ne sono almeno 2: uno è installato con
Komodo di Active State (che IMO è una porcheria tremenda per tutto il
resto), e un altro fa parte di un editor di per per WinOS che non mi ricordo
mai qual'è.... roba tipo OptiPerl o VisiPerl o VattelapescaPerl :-)
È decisamente utile per i principianti, perché ti permette di inserire un
certo testo in un campo, modificare la RE in un altro (con hints visivi di
correttezza sintattica) e in un terzo vedere il risultato in tempo reale
(mentre modifichi la RE). Personalmente trovo che sia l'unico vantaggio per
usare Komodo, quindi... non lo uso :-)
ciao
--
perl -MLWP::Simple -e "getprint(' 
http://perl.4pro.net
 ')"

resto) [...]
Credo tu faccia riferimento al debugger di RE basato sul lavoro di 
Mark-Jason Dominus, Rx.
 
http://perl.plover.com/Rx/
  << Rx is a backend for writing regex debuggers for Perl. >>
+++
Altra cosa che puo` tornare utile nello studio delle RE e` il modulo
YAPE::Regex::Explain di Jeff Pinyan (
http://japhy.perlmonk.org/
) che
sta pure scrivendo un libro sulle RE. Verra` pubblicato da Manning,
ma si puo` leggere quanto fatto finora qui: 
 
http://japhy.perlmonk.org/book/
ciao
Stefano

Sei sempre un'ottima fonte di links interessanti :-)


Sei sempre un'ottima fonte di links interessanti :-)
Chi sa fare fa.
Chi non sa fare insegna.
Chi non sa insegnare Googla :)
ciao
Stefano

viene riusata dal buffer successivo?
Direi di sì, se ho capito quello che intendi.
Ma siccome, a quanto pare, per te sono la stessa domanda, probabilmente non
ho capito quello che intendi (e, già che ci siamo, non escludiamo la
possibilità che io non abbia inteso quello che tu hai capito).
In ogni caso, puoi sempre sapere se un match ha avuto o no esito positivo,
controllando il risultato restituito. Per esempio, con un if:
   if ($core=~ m/\s*(\w*)\s*$/s) {
     fai_qualcosa_con $1;
   }
   if ($core=~ m/\<([0-3][0-9],[0-1][0-9],[0-9]{4}.*)\>/s) {
     fai_qualche_altra_cosa_con_un_altro $1;
   }
Oppure, come ti è stato già suggerito, puoi racchiudere i due match in due
gruppi diversi:
   {
     $core=~ m/\s*(\w*)\s*$/s;
     fai_qualcosa_con $1;
   }
   {
     $core=~ m/\<([0-3][0-9],[0-1][0-9],[0-9]{4}.*)\>/s;
     fai_qualche_altra_cosa_con_un_altro $1;
   }
Ciao.